Hookbase MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose targeting specific resources and actions, such as create/delete/get/list for sources, destinations, routes, cron jobs, tunnels, events, and deliveries. There is no overlap or ambiguity, with tools like hookbase_replay_delivery and hookbase_bulk_replay serving different but related retry functions.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern with the prefix 'hookbase_' and snake_case throughout, such as hookbase_create_destination, hookbase_list_events, and hookbase_update_route. This predictability makes it easy to understand and navigate the toolset.
Tool Count4/5
With 32 tools, the count is on the higher side but reasonable for a comprehensive webhook management system covering sources, destinations, routes, cron jobs, tunnels, events, deliveries, and analytics. It feels slightly heavy but each tool serves a distinct function, avoiding bloat.
Completeness5/5
The toolset provides complete CRUD and lifecycle coverage for all core entities (sources, destinations, routes, cron jobs, tunnels), plus operations for events, deliveries, analytics, debugging, and testing. There are no obvious gaps, enabling agents to handle full workflows from setup to monitoring and troubleshooting.
Average 3.2/5 across 32 of 32 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 16 commits in the last 12 weeks
- Last stable release on August 6, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
This repository includes a README.md file.
Tools from this server were used 12 times in the last 30 days.
This repository includes a glama.json configuration file.
This server has been verified by its author.
View related servers

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete a route' indicates a destructive mutation, but it lacks details on permissions required, whether deletion is reversible, side effects (e.g., impact on associated events or deliveries), rate limits, or error handling. This is a significant gap for a destructive tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at three words, front-loading the core action ('Delete a route') with zero wasted text. It's appropriately sized for a simple operation, though this brevity contributes to gaps in other dimensions like guidelines and transparency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature, lack of annotations, and no output schema, the description is incomplete. It doesn't address critical context such as what 'delete' entails (permanent vs. soft delete), confirmation requirements, return values, or error cases. For a mutation tool in a set with many siblings, more detail is needed to ensure safe and correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'route_id' documented as 'The ID of the route to delete'. The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline score is 3, as the schema adequately handles parameter semantics without description enhancement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Delete a route' clearly states the verb ('Delete') and resource ('a route'), making the basic purpose understandable. However, it doesn't differentiate this tool from its sibling deletion tools (e.g., hookbase_delete_cron_job, hookbase_delete_destination), which all follow the same 'Delete a [resource]' pattern, leaving the specific type of route unclear without context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing route), exclusions (e.g., not for bulk deletion), or related tools like hookbase_update_route or hookbase_get_route, which could be relevant for checking before deletion. Usage is implied only by the tool name in context with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't cover critical aspects like authentication requirements, error handling, whether changes are reversible, rate limits beyond the parameter, or what happens to unspecified fields. For a mutation tool with 10 parameters, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every part of the sentence earns its place by conveying the essential purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (10 parameters, mutation operation, no annotations, no output schema), the description is incomplete. It doesn't address behavioral traits, usage context, or output expectations. For a tool that modifies configurations with many options, more guidance is needed to help an agent use it correctly and safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are documented in the schema itself. The description adds no additional meaning beyond the schema's details (e.g., it doesn't explain relationships between parameters like 'auth_type' and 'auth_config'). With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't detract either.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('Update') and resource ('existing destination configuration'), which provides a basic understanding. However, it lacks specificity about what a 'destination' is in this context and doesn't differentiate from sibling tools like 'hookbase_update_route' or 'hookbase_update_source' beyond the resource name. The purpose is clear but vague about the domain.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing destination ID), compare to sibling tools like 'hookbase_create_destination' or 'hookbase_test_destination', or specify contexts where updates are appropriate. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool creates a cron job but doesn't disclose permissions needed, whether creation is idempotent, error handling, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 9 parameters, no annotations, and no output schema, the description is insufficient. It lacks behavioral context, usage guidelines, and any indication of what the tool returns, leaving significant gaps for the agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 9 parameters. The description adds no parameter-specific information beyond what's in the schema, such as examples beyond the cron expression or clarification on payload usage. Baseline 3 is appropriate when schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a new scheduled cron job that makes HTTP requests, specifying both the action (create) and resource (cron job). It distinguishes from siblings like hookbase_list_cron_jobs and hookbase_delete_cron_job by focusing on creation, though it doesn't explicitly contrast with hookbase_trigger_cron.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when not to use it, or how it relates to sibling tools like hookbase_trigger_cron or hookbase_list_cron_jobs, leaving the agent without contextual usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but doesn't mention permission requirements, whether this is idempotent, what happens on duplicate names/URLs, or what the response contains. For a mutation tool with 8 parameters, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states the core purpose, and the second provides valuable context about what destinations are. There's zero wasted verbiage or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 8 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens after creation, what the response looks like, error conditions, or how this tool relates to the broader webhook system. The context about destinations being 'endpoints where webhooks are forwarded' is helpful but doesn't compensate for missing behavioral details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema. Baseline 3 is appropriate when the schema does the heavy lifting, though the description could have provided higher-level context about parameter relationships.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new webhook destination') and resource ('webhook destination'), with additional context about what destinations are ('endpoints where webhooks are forwarded after processing'). However, it doesn't explicitly differentiate from sibling tools like hookbase_create_route or hookbase_create_source, which likely create different resource types in the same system.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like hookbase_update_destination or hookbase_test_destination. It mentions what destinations are used for ('where webhooks are forwarded'), but offers no explicit when/when-not instructions or comparisons with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool creates a tunnel and mentions CLI connectivity, but lacks details on permissions, rate limits, whether the tunnel is persistent, error conditions, or what happens on creation failure. For a creation tool with zero annotation coverage, this is insufficient behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main action (create tunnel) and followed by a usage note. It's efficient with minimal waste, though it could be slightly more structured by separating purpose from implementation details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a creation tool with potential behavioral complexity, the description is incomplete. It covers the basic purpose but lacks details on what the tool returns, error handling, or operational context needed for an AI agent to use it effectively without trial and error.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (name and subdomain) fully. The description adds no parameter-specific information beyond what's in the schema, such as examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a new localhost tunnel and mentions it can be connected using the Hookbase CLI to forward webhooks to a local server. This specifies the verb (create), resource (localhost tunnel), and purpose (forward webhooks). However, it doesn't explicitly differentiate from sibling tools like hookbase_create_destination or hookbase_create_source, which also create resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions the CLI connection but doesn't specify scenarios, prerequisites, or exclusions compared to other tunnel-related tools like hookbase_list_tunnels or hookbase_delete_tunnel. Usage context is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the action ('Delete') but doesn't disclose behavioral traits such as whether deletion is permanent, requires specific permissions, has side effects (e.g., stopping scheduled tasks), or what happens on success/failure. For a destructive operation with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with zero waste, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive delete operation), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like permanence, permissions, or response format, which are critical for safe and effective use. The description should do more to compensate for missing structured data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with 'job_id' clearly documented. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or sourcing guidance. Baseline 3 is appropriate since the schema does the heavy lifting, but no extra value is added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Delete') and resource ('a scheduled cron job'), making the purpose unambiguous. It distinguishes from siblings like 'hookbase_list_cron_jobs' (list) and 'hookbase_trigger_cron' (trigger), though it doesn't explicitly contrast with them. The specificity is good but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing cron job ID), exclusions, or comparisons to siblings like 'hookbase_list_cron_jobs' for finding IDs. Usage is implied by the action but not explicitly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is destructive ('Delete') but doesn't specify whether deletion is permanent, reversible, or has side effects. It also omits information about authentication requirements, rate limits, error conditions, or what happens after deletion. For a destructive operation with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable. Every word earns its place, and there's no redundant or verbose phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what 'delete' entails behaviorally (e.g., permanent removal, cleanup of associated resources), what the expected outcome is, or potential errors. Given the complexity of a delete operation and the lack of structured data, the description should provide more contextual guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'tunnel_id' fully documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema (e.g., format examples, where to find tunnel IDs, or validation rules). With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('a localhost tunnel'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling delete tools like hookbase_delete_cron_job or hookbase_delete_destination, but the specificity of 'localhost tunnel' provides some implicit distinction. The description avoids tautology by not simply restating the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing tunnel), when-not-to-use scenarios, or relationships with sibling tools like hookbase_list_tunnels (to identify what to delete) or hookbase_create_tunnel. The agent must infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions that deliveries 'represent attempts to forward webhooks to destinations,' which adds some context about the data. However, it fails to disclose critical behavioral traits such as pagination behavior (implied by 'offset' but not explained), rate limits, authentication needs, or what the output looks like. For a query tool with no annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with two sentences that directly state the tool's function and clarify what deliveries are. There is no wasted text, making it efficient. However, it could be slightly more structured by explicitly mentioning pagination or filtering context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a query tool with 5 parameters and no output schema, the description is incomplete. It lacks details on output format, pagination behavior, error handling, or usage context. Without annotations or an output schema, the agent has insufficient information to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by mentioning 'optional filters' but does not provide additional semantics beyond what the schema specifies. This meets the baseline of 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Query webhook deliveries with optional filters.' It specifies the verb ('query') and resource ('webhook deliveries'), and distinguishes them as 'attempts to forward webhooks to destinations.' However, it does not explicitly differentiate from sibling tools like 'hookbase_list_events' or 'hookbase_get_delivery,' which reduces the score from a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'optional filters' but does not specify scenarios, prerequisites, or exclusions. Without any context on usage compared to siblings like 'hookbase_list_events' or 'hookbase_get_delivery,' the agent lacks direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool queries events but lacks critical behavioral details: it doesn't mention pagination behavior (implied by offset/limit but not explained), rate limits, authentication requirements, or what the response format looks like (no output schema). The description is too minimal for a tool with 7 parameters and no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose in the first clause. It consists of two efficient sentences with no wasted words. However, it could be slightly more structured by explicitly separating purpose from context, but it's still highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, no output schema), the description is incomplete. It lacks behavioral context (e.g., pagination, auth), usage guidelines, and any explanation of return values. While the schema covers parameters well, the description fails to provide the necessary operational context for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 7 parameters with descriptions, defaults, and enums. The description adds no additional parameter semantics beyond mentioning 'optional filters' generically. This meets the baseline of 3 when the schema does the heavy lifting, but the description doesn't compensate or enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Query webhook events with optional filters' specifies the verb (query) and resource (webhook events). It distinguishes from siblings like hookbase_get_event (singular) and hookbase_list_deliveries (different resource), though not explicitly. However, it doesn't fully differentiate from other list tools like hookbase_list_sources, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'optional filters' but doesn't specify scenarios or prerequisites. For example, it doesn't contrast with hookbase_get_event (single event) or hookbase_list_deliveries (deliveries vs events), leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't mention permissions required, whether changes are reversible, error handling, or what happens to unspecified fields (e.g., partial updates). This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 8 parameters, no annotations, and no output schema, the description is inadequate. It doesn't cover behavioral aspects like side effects, error conditions, or response format, leaving the agent with insufficient context to use the tool effectively beyond basic parameter passing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds no additional meaning beyond what's in the schema, such as explaining relationships between parameters or usage examples. Baseline 3 is appropriate when the schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and resource ('existing route configuration'), which is specific and unambiguous. However, it doesn't distinguish this tool from its sibling 'hookbase_update_destination' and 'hookbase_update_source', which have similar update patterns for different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'hookbase_create_route' or 'hookbase_delete_route'. The description lacks context about prerequisites, such as needing an existing route ID, or when updates might be appropriate versus creating/deleting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation but doesn't mention whether it's idempotent, what permissions are required, whether changes are reversible, what happens on partial updates, or error conditions. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a tool with comprehensive schema documentation and gets straight to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'update' entails operationally, what the response looks like, error handling, or side effects. The agent must rely entirely on the schema for understanding, which is inadequate for behavioral expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. It doesn't explain relationships between parameters or provide usage examples. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and resource ('existing webhook source configuration'), making the purpose immediately understandable. It distinguishes this from creation tools like 'hookbase_create_source' by specifying 'existing', but doesn't explicitly differentiate from other update tools like 'hookbase_update_destination' or 'hookbase_update_route' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing source), when not to use it, or how it differs from other update tools for destinations or routes. The agent must infer usage from the tool name and sibling list alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it 'creates' without disclosing behavioral traits. It doesn't mention permissions required, whether creation is idempotent, what happens on failure, rate limits, or what the response contains. For a creation tool with 8 parameters, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured by separating the optional filter aspect, but it avoids unnecessary words and gets straight to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address what happens after creation (e.g., returns a route ID), error conditions, or how it interacts with other tools like hookbase_get_route. The context signals indicate high complexity that isn't adequately covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds minimal value by mentioning 'optionally add filters' which hints at filter_id and filter_conditions, but doesn't provide additional semantic context beyond what's already in the schema descriptions. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Create a new route') and the resource ('connecting a source to a destination'), distinguishing it from siblings like hookbase_create_source or hookbase_create_destination. It also mentions optional filtering functionality, which adds specificity beyond basic creation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like hookbase_update_route or hookbase_delete_route. It mentions optional filters but doesn't explain prerequisites (e.g., needing existing source/destination IDs) or when to choose inline filters versus filter_id.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'detailed information' and 'authentication configuration', which hints at read-only behavior, but doesn't explicitly state whether this is a safe read operation, what permissions are required, or how errors are handled. For a tool with zero annotation coverage, this is insufficient disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific destination') and adds a useful detail ('including authentication configuration'). There is no wasted verbiage, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter with 100% schema coverage and no output schema, the description is minimally adequate. It covers the what but lacks context on usage, behavior, or output format. For a simple read tool, it's passable but leaves gaps in guidance and transparency that could hinder optimal agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'destination_id' fully documented in the schema. The description adds no additional meaning about the parameter (e.g., format examples or where to find the ID). Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a specific destination', including the scope 'authentication configuration'. It distinguishes from sibling tools like hookbase_list_destinations (which lists multiple) and hookbase_update_destination (which modifies). However, it doesn't explicitly contrast with all siblings like hookbase_test_destination, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a destination ID), exclusions, or comparisons to siblings like hookbase_list_destinations (for browsing) or hookbase_test_destination (for validation). This lack of context leaves the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool generates a cURL command, implying it's a read-only operation that outputs a command string rather than executing the replay. However, it doesn't clarify whether this requires specific permissions, what the output format looks like (e.g., plain text, JSON), or any rate limits. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence: 'Generate a cURL command to replay an event for debugging purposes.' It is front-loaded with the core action and includes essential context without unnecessary words. Every part of the sentence earns its place, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple with one parameter) and the lack of annotations and output schema, the description is moderately complete. It clearly states what the tool does but lacks details on behavioral aspects like output format or usage constraints. For a debugging tool, more context on how the generated cURL command can be used would be beneficial, but it meets the minimum viable threshold.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'event_id' documented as 'The ID of the event to generate cURL for.' The description doesn't add any additional meaning beyond this, such as format examples or constraints. Since schema coverage is high, the baseline score of 3 is appropriate, as the schema already provides adequate parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a cURL command to replay an event for debugging purposes.' It specifies the verb ('Generate'), resource ('cURL command'), and context ('for debugging purposes'). However, it doesn't explicitly distinguish this from sibling tools like 'hookbase_replay_delivery' or 'hookbase_bulk_replay', which might also involve event replay but with different approaches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance on when to use this tool. It mentions 'for debugging purposes,' which gives some context, but doesn't specify when to choose this over alternatives like 'hookbase_replay_delivery' (which might replay without generating a cURL command) or 'hookbase_get_event' (which might retrieve event details without replay). No explicit when-not-to-use or prerequisite information is included.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions retrieving 'detailed information' but doesn't disclose behavioral traits such as whether this is a read-only operation, potential rate limits, authentication requirements, or what happens if the source_id is invalid. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific webhook source') and adds useful specifics ('including its configuration and statistics'). There is zero waste, and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and high schema coverage (100%), the description is minimally adequate. However, with no annotations and no output schema, it lacks details on behavioral aspects (e.g., safety, error handling) and return values, which are important for a read operation. It meets basic needs but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'source_id' fully documented in the schema. The description adds no additional parameter semantics beyond implying the tool retrieves data for a specific source, which aligns with the schema. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('webhook source') with specific details ('detailed information including configuration and statistics'). It distinguishes from sibling tools like hookbase_list_sources (which lists multiple sources) by focusing on a single source. However, it doesn't explicitly contrast with other get_* tools (e.g., hookbase_get_destination), making it a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a source_id), when not to use it (e.g., for bulk operations), or refer to sibling tools like hookbase_list_sources for listing multiple sources. This lack of contextual direction leaves the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool checks status and shows statistics, implying a read-only operation, but doesn't specify authentication needs, rate limits, error conditions, or what 'live statistics' entails (e.g., metrics like latency or throughput). For a tool with zero annotation coverage, this leaves significant behavioral gaps, scoring a 2.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: two concise sentences that directly state the tool's function and output. Every sentence earns its place by providing essential information without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and 100% schema coverage, the description is somewhat complete but lacks output details (no output schema) and behavioral context. It covers the basic purpose but doesn't fully compensate for missing annotations or output schema, making it minimally adequate with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 100% description coverage ('The ID of the tunnel to check'), so the schema fully documents the parameter. The description adds no additional meaning beyond the schema, such as format examples or where to obtain the tunnel ID. With high schema coverage, the baseline is 3, and the description doesn't compensate further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check the connection status of a tunnel' specifies the verb ('check') and resource ('tunnel'), and 'Shows whether the tunnel is connected and live statistics' elaborates on the output. It distinguishes from siblings like 'hookbase_list_tunnels' (which lists tunnels) and 'hookbase_get_destination' (which checks a different resource), though it doesn't explicitly name alternatives. This is clear but lacks explicit sibling differentiation, warranting a 4.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a tunnel ID from 'hookbase_list_tunnels'), exclusions (e.g., not for checking other resources), or compare to similar tools like 'hookbase_get_destination'. With no usage context provided, this scores a 2.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('List all webhook destinations') but lacks details on permissions required, pagination behavior, rate limits, error handling, or output format. This is inadequate for a tool that likely returns organizational data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences that efficiently convey the core purpose and a brief clarification about destinations. Every word adds value without redundancy, making it front-loaded and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of listing organizational resources, lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like data scope, ordering, or response structure, leaving gaps that could hinder correct tool invocation by an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description correctly doesn't discuss parameters, and the baseline for 0 parameters is 4, as it avoids unnecessary information while matching the schema's simplicity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all webhook destinations in the organization'), making the purpose specific and understandable. It distinguishes webhook destinations from other resources but doesn't explicitly differentiate from sibling list tools like hookbase_list_routes or hookbase_list_sources, which follow a similar pattern.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), compare it to hookbase_get_destination for single-destination retrieval, or specify use cases like auditing or setup. This leaves the agent without contextual usage cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is a 'Get' operation, implying read-only behavior, but doesn't disclose any behavioral traits such as authentication requirements, rate limits, pagination, or what happens if no data exists for the time range. The description adds minimal context beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and lists key metrics. It avoids unnecessary words, though it could be slightly more structured (e.g., separating scope from metrics).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (analytics aggregation), no annotations, and no output schema, the description is minimally adequate. It covers what metrics are included but lacks details on output format, error handling, or organizational scope. Completeness is limited to the basic purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'range' fully documented in the schema (including enum values and default). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('dashboard analytics and metrics for the organization'), specifying the types of metrics included (event counts, delivery success rates, top sources/destinations). It distinguishes from sibling tools by focusing on aggregated analytics rather than individual resources or operations, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for viewing organizational analytics, but provides no explicit guidance on when to use this tool versus alternatives (e.g., vs. hookbase_list_events for raw event data or hookbase_get_delivery for specific delivery metrics). 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a list operation but doesn't describe return format, pagination behavior, sorting, filtering capabilities, or error conditions. The explanation of what routes are adds some context, but doesn't cover how the listing behaves operationally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that efficiently convey the purpose and provide helpful context about what routes are. The first sentence states the action clearly, and the second adds valuable explanatory context without redundancy. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list operation with no parameters and no output schema, the description is adequate but has gaps. It explains what's being listed and provides domain context about routes, but doesn't describe the return format or behavioral aspects. Without annotations or output schema, the agent lacks information about what the response contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description doesn't need to explain parameters, and it doesn't attempt to describe any nonexistent parameters. The mention of 'all routes' implies no filtering parameters exist, which aligns with the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all routes in the organization'), and explains what routes are ('connect sources to destinations and define how webhooks are processed'). It distinguishes from siblings like hookbase_get_route (singular) by specifying 'all routes'. However, it doesn't explicitly differentiate from other list tools like hookbase_list_sources or hookbase_list_destinations beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when you'd want to list all routes versus getting a specific route with hookbase_get_route, or how this relates to other list operations. There's no context about prerequisites, timing, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions that sources are endpoints receiving webhooks, which adds some context, but lacks critical behavioral details like pagination, sorting, filtering, rate limits, authentication requirements, or response format. For a list operation with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero waste. The first sentence states the core purpose, and the second adds helpful clarification about what sources are. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does and what sources are, but for a list operation, it should ideally mention behavioral aspects like pagination or filtering constraints. Without annotations or output schema, more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate given the empty schema. Baseline is 4 for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List all') and resource ('webhook sources in the organization'), with additional context that sources are endpoints receiving incoming webhooks. It distinguishes from siblings like hookbase_get_source (singular) by specifying 'all' sources, but doesn't explicitly contrast with other list tools like hookbase_list_destinations or hookbase_list_routes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, timing considerations, or comparisons to sibling tools like hookbase_get_source for individual sources or other list operations for different resource types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions that tunnels 'allow forwarding webhooks to local development servers,' which adds some context about functionality, but lacks critical behavioral details: it doesn't specify if this is a read-only operation, what the output format is (e.g., list of objects with fields), whether it requires specific permissions, or if there are rate limits. For a list operation with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the core purpose ('List all localhost tunnels in the organization') and followed by a brief explanatory note. Every sentence earns its place by adding value: the first defines the action and scope, and the second provides context about tunnels. There is no wasted text, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity is low (a list operation with 0 parameters), no annotations, and no output schema, the description is minimally adequate. It explains what the tool does and adds some context about tunnels, but it lacks details on output format, authentication, or behavioral traits. For a simple list tool, this is acceptable but leaves clear gaps that could hinder an agent's ability to use it effectively without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameters need documentation. The description doesn't add parameter details, which is appropriate here. Baseline is 4 for 0 parameters, as the schema fully covers the absence of inputs, and the description doesn't need to compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List all') and resource ('localhost tunnels in the organization'), with a brief explanation of what tunnels do ('allow forwarding webhooks to local development servers'). It distinguishes from siblings like 'hookbase_get_tunnel_status' by focusing on listing all tunnels rather than getting status of a specific one. However, it doesn't explicitly differentiate from other list operations like 'hookbase_list_destinations' or 'hookbase_list_sources' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication needs), when not to use it, or compare it to related tools like 'hookbase_get_tunnel_status' for specific tunnel details or 'hookbase_create_tunnel' for creating new ones. Usage is implied by the verb 'List,' but no explicit context or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states what information is returned (response body, error details) but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or whether this is a read-only operation. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and includes specific details about what information is retrieved. Every word serves a purpose with no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose but lacks completeness for a tool that retrieves detailed delivery data. It doesn't explain return format, error conditions, or operational constraints that would help an agent use it correctly in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with one parameter ('delivery_id') fully documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage without compensating value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific delivery'), specifying it includes response body and error details. It distinguishes from sibling 'hookbase_list_deliveries' by focusing on a single delivery rather than listing multiple, though it doesn't explicitly name the sibling alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when detailed delivery info is needed, but doesn't provide explicit guidance on when to use this vs. alternatives like 'hookbase_list_deliveries' or 'hookbase_replay_delivery'. 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get detailed information'), which is clear, but it doesn't mention any behavioral traits such as permissions required, error handling, rate limits, or what format the information is returned in. For a tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific route') and adds specific details ('including filter and transform configuration'). There is no wasted text, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter, no output schema, no annotations), the description is somewhat complete but lacks depth. It covers the purpose but misses behavioral context like return format or error handling. Without annotations or output schema, more guidance would be helpful, but it's minimally adequate for a simple read tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'route_id' documented as 'The ID of the route to retrieve'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get detailed information') and resource ('about a specific route'), specifying what information is included ('filter and transform configuration'). It distinguishes from siblings like hookbase_list_routes (which lists multiple routes) by focusing on a single route, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when detailed information about a specific route is needed, but it doesn't explicitly state when to use this tool versus alternatives like hookbase_list_routes or hookbase_update_route. No exclusions or prerequisites are mentioned, leaving the context somewhat vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool 'returns response status and timing,' which is useful, but lacks critical details such as whether this is a read-only operation, if it requires specific permissions, potential side effects (e.g., triggering alerts), or error handling. For a connectivity test with no annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences that are front-loaded with the core purpose and efficiently convey the return value. Every word earns its place, with no redundancy or unnecessary elaboration, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (testing connectivity) and lack of annotations or output schema, the description is partially complete. It covers the basic action and return types but misses behavioral details like side effects or error conditions. It is adequate for a simple test tool but could be more informative to fully guide an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'destination_id' documented as 'The ID of the destination to test.' The description adds no additional parameter semantics beyond what the schema provides, such as format examples or validation rules. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('test connectivity by sending a test request') and resource ('to a destination'), distinguishing it from sibling tools like hookbase_get_destination (which retrieves destination details) or hookbase_update_destination (which modifies destination settings). The purpose is unambiguous and actionable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., whether the destination must be configured first), nor does it differentiate from similar tools like hookbase_get_destination (which might check status without testing connectivity). Usage context is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the output includes 'full payload and all delivery attempts', which adds some behavioral context beyond the basic 'get' operation. However, it lacks details on permissions, rate limits, error handling, or response format, which are important for a read operation with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific event') and adds valuable scope details ('including the full payload and all delivery attempts'). There is no wasted verbiage, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and high schema coverage, the description is adequate but has gaps. It lacks an output schema, and with no annotations, it does not fully cover behavioral aspects like error conditions or response structure, making it minimally complete for a simple read tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'event_id' clearly documented. The description does not add any additional meaning or context about the parameter beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific event'), specifying the scope ('full payload and all delivery attempts'). It distinguishes from siblings like 'hookbase_list_events' (which lists events) and 'hookbase_get_event_debug' (which likely provides debug-specific details).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when detailed event information is needed, but does not explicitly state when to use this tool versus alternatives like 'hookbase_get_event_debug' or 'hookbase_list_events'. No exclusions or prerequisites are mentioned, leaving usage context somewhat vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only mentions the purpose and context. It doesn't disclose behavioral traits like whether this is a safe operation, what permissions are required, rate limits, whether it's idempotent, or what happens to already-succeeded deliveries. The description adds minimal value beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: the first states the core functionality, the second provides usage context. It's front-loaded with the main purpose and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a single well-documented parameter, the description provides adequate basic information but lacks completeness for a mutation tool. It doesn't explain what 'retry' means operationally, what the response looks like, or potential side effects, which would be helpful for an agent using this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (parameter 'delivery_ids' is well-documented in schema), so the baseline is 3. The description doesn't add any parameter-specific information beyond what's in the schema, but it doesn't need to since the schema already fully describes the single parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Retry multiple failed deliveries') and resource ('deliveries'), distinguishing it from sibling tools like 'hookbase_replay_delivery' (singular) and 'hookbase_list_deliveries' (list only). It explicitly mentions bulk operation ('at once') and the target state ('failed deliveries').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('Useful for recovering from destination outages') and implies it's for retrying failed deliveries. However, it doesn't explicitly state when NOT to use it or name alternatives like 'hookbase_replay_delivery' for single retries, though the sibling tool list makes this distinction apparent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that sources 'receive incoming webhooks' and 'can be connected to destinations via routes,' but lacks critical details like authentication requirements, whether this is a mutating operation (implied by 'Create'), rate limits beyond the parameter, or what happens on success/failure. For a creation tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two concise sentences that are front-loaded with the core purpose. Every sentence earns its place by defining the tool's function and its role in the system, with zero wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (creation operation with 6 parameters) and the absence of both annotations and an output schema, the description is incomplete. It covers the basic purpose but lacks behavioral details (e.g., permissions, side effects) and output information, making it only minimally viable for an agent to use correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain parameter interactions or usage examples), resulting in the baseline score of 3 for adequate but not enhanced parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Create a new webhook source') and resource ('webhook source'), distinguishing it from siblings like create_destination or create_route by specifying that sources receive incoming webhooks and can be connected to destinations via routes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use this tool (for creating webhook sources that receive incoming webhooks), but it doesn't explicitly state when not to use it or name specific alternatives among the many sibling tools, such as create_destination for different purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the action ('re-send the original webhook payload') but lacks details on permissions required, rate limits, whether it's idempotent, or what happens on success/failure. For a mutation tool, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by a clarifying detail. Every word earns its place with no redundancy or fluff, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with no annotations and no output schema), the description is minimally complete. It states what the tool does but lacks behavioral context and output details. It's adequate for basic understanding but leaves gaps for an agent to operate confidently without additional information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents the single parameter 'delivery_id' fully. The description adds no additional parameter semantics beyond what the schema provides, but with 0 parameters needing extra explanation, a baseline of 4 is appropriate as it doesn't detract from clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Retry a failed delivery') and resource ('webhook payload to the destination'), distinguishing it from siblings like hookbase_bulk_replay (bulk operations) or hookbase_get_delivery (read-only). It uses precise verbs and identifies the exact scope of the operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'failed delivery,' suggesting it should be used when a delivery has previously failed. However, it does not explicitly state when not to use it (e.g., for successful deliveries) or name alternatives like hookbase_bulk_replay for multiple retries, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the action ('Manually trigger') but lacks details on permissions needed, side effects (e.g., if this affects the job's future schedule), rate limits, or what happens on success/failure. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Manually trigger a cron job') and adds necessary qualification ('immediately, regardless of its schedule'). There is zero waste, and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with no annotations and no output schema), the description is minimal but clear on purpose. However, it lacks behavioral details (e.g., effects, permissions) and output information, making it incomplete for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'job_id' fully documented in the schema. The description does not add any additional meaning beyond what the schema provides, such as format examples or where to find the job ID. Baseline 3 is appropriate when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Manually trigger') and resource ('a cron job'), with the specific scope 'immediately, regardless of its schedule'. It distinguishes from siblings like hookbase_list_cron_jobs (list) and hookbase_create_cron_job (create).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('immediately, regardless of its schedule'), suggesting when to use it versus letting the cron job run on schedule. However, it does not explicitly mention when not to use it or name alternatives like hookbase_replay_delivery for similar triggering actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 a critical behavioral trait: 'This will also delete all associated routes,' which indicates a destructive, cascading effect beyond just the destination. This is valuable context for understanding the tool's impact, though it doesn't cover other aspects like permissions, error handling, or confirmation prompts.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two short sentences that are front-loaded with the primary action and immediately follow with the key side effect. Every word earns its place, with no redundant or unnecessary information, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive delete operation with cascading effects), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers the main action and a critical side effect, but lacks details on prerequisites (e.g., authentication), error conditions, or what happens upon success. For a mutation tool with no structured support, it should do more to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'destination_id' parameter clearly documented. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain format or constraints for 'destination_id'). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete a destination') and distinguishes it from sibling tools like 'hookbase_delete_route' or 'hookbase_delete_source' by specifying the resource type. It goes beyond the tool name by adding the consequence of deleting associated routes, which helps differentiate it from other delete operations in the sibling set.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when deleting a destination is needed, but it doesn't explicitly state when to use this tool versus alternatives (e.g., 'hookbase_update_destination' for modifications or 'hookbase_list_destinations' for viewing). It mentions the side effect of deleting associated routes, which provides some context but not clear exclusions or comparisons to other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a destructive operation ('Delete') and reveals a critical behavioral trait: cascading deletion of associated routes. This adds valuable context beyond the basic action, though it could mention permissions or irreversible effects for a higher score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences that directly convey the action and its side effect. Every word earns its place, and it is front-loaded with the primary purpose, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature and lack of annotations or output schema, the description is reasonably complete. It covers the main action and a key side effect (deleting routes), but could improve by mentioning potential impacts like data loss or confirmation needs, which would enhance completeness for a deletion tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the parameter 'source_id' fully documented in the schema. The description does not add any additional meaning or details about the parameter beyond what the schema provides, such as format or examples. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete a webhook source') and identifies the resource ('webhook source'), distinguishing it from sibling tools like hookbase_delete_destination or hookbase_delete_route. It goes beyond the tool name by specifying what gets deleted, 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when deleting a source is needed, but it does not explicitly state when to use this tool versus alternatives (e.g., hookbase_update_source for modifications) or provide exclusions. It mentions cascading deletion of routes, which offers some context but lacks explicit guidance on prerequisites or scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 states the tool lists all cron jobs, implying a read-only operation, but doesn't disclose behavioral traits like pagination, rate limits, authentication needs, or output format. The extra context about cron jobs making HTTP requests adds some value beyond basic listing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences: the first states the purpose, and the second adds helpful context about cron jobs. Every sentence earns its place, with no wasted words, and it's front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 0 parameters, the description is complete for a simple list tool but lacks details on behavioral aspects like return format or limitations. It's adequate but has clear gaps in transparency for a tool with no structured data support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is appropriate, and the baseline for 0 parameters is 4, as it doesn't need to compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List all') and resource ('scheduled cron jobs in the organization'), with additional context about what cron jobs do ('make HTTP requests on a schedule'). It distinguishes from siblings like hookbase_create_cron_job (create vs list) and hookbase_trigger_cron (trigger vs list).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for viewing all cron jobs, with no explicit exclusions or alternatives mentioned. It doesn't specify when not to use it or name alternatives like hookbase_get_event (for specific events vs all jobs), but the context is clear for a listing operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-server MCP server](https://glama.ai/mcp/servers/HookbaseApp/mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/HookbaseApp/mcp-server)

Score Badge

Copy to your README.md:

[![mcp-server MCP server](https://glama.ai/mcp/servers/HookbaseApp/mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/HookbaseApp/mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/HookbaseApp/mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server