@houtini/contentmarketingideas

Official

by houtini-ai

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools target distinct resources (sites, sources, briefs, articles, GSC data, corpus), so an agent can usually tell them apart. However, some overlap exists: generate_article, generate_draft, and create_article all involve content creation, and the many gsc_* tools are similar in nature. Descriptions help, but a few pairs are ambiguous.
Naming Consistency3/5
The majority of tools follow a consistent verb_noun pattern (list_*, get_*, create_*, update_*, delete_*, trigger_*). However, the gsc_* family uses noun_noun/adjective prefixes (gsc_summary, gsc_queries), and brief_feedback breaks the verb-first pattern. This mixed convention makes the API less predictable.
Tool Count2/5
59 tools is a very large surface for a single MCP server. While the broad scope of content marketing automation justifies some heft, the sheer number will overwhelm agents and increase selection errors. It would benefit from splitting into focused servers or consolidating related tools.
Completeness4/5
The toolset covers the full content lifecycle: sources, briefs, drafts, articles, publishing, plus GSC analytics, RAG corpus, coverage, and growth plans. Core workflows are well-supported with no showstopper gaps. Minor omissions like no update_profile or list_drafts are workarounds rather than dead ends.
Average 3.5/5 across 59 of 59 tools scored. Lowest: 2.8/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

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?
With no annotations provided, the description carries the full burden for behavioral disclosure, but it only restates the tool's purpose. It does not mention pagination defaults, ordering, what fields are returned, or any side effects, leaving significant behavioral traits undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise and front-loaded, but it is also under-specified. It is not overly verbose, yet the lack of relevant detail detracts from what would otherwise be a highly efficient structure.
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 that there is no output schema and no annotations, the description should explain what the response contains or how pagination behaves. It merely states 'List email delivery history,' leaving the return format and pagination behavior unspecified, making the tool description inadequate for a complete understanding.
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 already provides 100% coverage with descriptions for 'limit' ('Max results') and 'offset' ('Pagination offset'), so the description adds no additional parameter meaning. According to the rubric, this yields a baseline score of 3.
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 'List email delivery history' uses a specific verb ('List') and resource ('email delivery history'), clearly distinguishing it from other list_* siblings such as list_articles or list_sources. It lacks an explicit scope, such as date range or recipient filtering, but the core purpose is unambiguous.
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 about when to use this tool versus alternatives like list_account_emails or get_publish_status, nor are any exclusions or context given. The description only states the basic action without situating it within the broader toolset.
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 does not explain what 'gaining' means, what time period is considered, or what the returned data looks like, providing minimal insight into the tool's 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, concise sentence with no unnecessary words. It is front-loaded and efficiently conveys the core purpose, matching the standard of the highest conciseness scores.
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?
The description is too terse given the lack of an output schema and annotations, and the presence of many closely related sibling tools. It does not specify what results are returned, how 'gaining' is measured, or how this tool differs from gsc_opportunities and gsc_growing_queries, making it incomplete for effective 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?
The schema covers 100% of the single parameter (site_id with description 'Site ID'), which is sufficient. The description adds no additional parameter details, but given the high schema coverage, a 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 tool returns pages that are gaining search performance over time, using a specific verb and resource. However, it does not explicitly distinguish it from sibling tools like gsc_opportunities or gsc_growing_queries, which could overlap in purpose.
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?
There is no guidance on when to use this tool versus alternatives. The description does not mention any exclusions or compare with other GSC tools, leaving the agent to infer its place in the workflow.
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 a basic function but does not mention data freshness, default time range, what 'top' refers to (e.g., by clicks), or any limitations. Since 'Get' implies a read operation, but without explicit safety cues or behavioral notes, the transparency is insufficient for an agent to understand ramifications.
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 sentence that front-loads the core function: 'Get top GSC queries with performance metrics.' Every word contributes to meaning, with no filler or redundancy. It is appropriately concise for a simple data retrieval tool.
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?
Although the schema documents parameters, the description lacks context about the return payload, default date ranges, or metric definitions. With no output schema and no annotations, the description should explain what performance metrics are returned and any default behavior. The presence of numerous GSC sibling tools without differentiation further limits completeness.
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 clear text for sort ('Sort by: clicks, impressions, position, ctr'), limit ('Max results (default 50)'), and site_id ('Site ID'). The description adds no additional meaning beyond what the schema already provides. Baseline 3 is appropriate when the schema handles parameter explanation fully.
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 'Get top GSC queries with performance metrics' uses a specific verb ('Get') and resource ('GSC queries'), clearly indicating a query-level retrieval tool. It is reasonably distinct from sibling tools like gsc_growing_queries or gsc_declining_queries, though it does not explicitly differentiate from them. The mention of 'top' and 'performance metrics' conveys the core purpose effectively.
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?
There is no guidance on when to use this tool versus the many GSC-related siblings such as gsc_summary, gsc_growing_queries, or gsc_declining_queries. The description only states what it does, offering no preferred contexts, exclusions, or alternative recommendations. This leaves the agent to infer usage from the tool name and context.
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, the description must explain behaviors like side effects, auth requirements, or whether the sync overwrites data. 'Sync' implies mutation but lacks details such as whether it's incremental or full, or if it can be safely re-run.
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 one short sentence with no filler. It front-loads the verb and is easy to scan.
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 sync tool with no annotations or output schema, the description under-specifies behavior, including what happens on conflict, expected runtime, or return value. The minimal text leaves many questions unanswered.
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 already defines site_id, and the description maps to it with 'for a site'. Coverage is 100%, so the description adds minimal extra meaning beyond confirming which site.
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 identifies the action (sync) and resource (Google Search Console data) with a site scope. It distinguishes from sibling analysis tools like gsc_summary and gsc_queries by implying a data transfer operation, though it could be more explicit about what 'sync' entails.
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 sync vs. use the other GSC read tools. There are no prerequisites or alternatives 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 disclosing behavioral traits. It only says 'Update an article' and lists fields, which implies mutation but does not explain whether updates are partial or full replacements, what happens to unspecified fields, or any error behavior. For a mutation tool, this is a significant gap and offers minimal transparency.
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 primary action and resource, followed by a parenthetical list of editable fields. It contains no waste or redundancy. While it lacks additional structural elements like usage examples, it is highly concise and scannable for a simple tool.
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 absence of annotations and an output schema, the description is incomplete. It does not mention return values, side effects (e.g., whether existing data is overwritten), or conditions under which the update succeeds or fails. The schema covers parameter details, but the overall behavioral context is missing, making this inadequate for an agent to use confidently.
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 six parameters. The description lists the fields in a more compact, readable form, which adds marginal value, but it uses different names ('research' vs 'custom_research', 'notes' vs 'custom_notes') that could cause slight confusion. Per the rubric, with high schema coverage, a baseline 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 ('Update') and the resource ('an article'), and lists the specific fields that can be updated (title, markdown, research, notes, keyword). This is a specific verb+resource combination that distinguishes it from sibling tools like create_article, delete_article, and publish_article. However, it does not explicitly mention that it modifies an existing article, so it falls short of 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 does not state prerequisites (e.g., the article must already exist), nor does it mention scenarios where create_article or generate_article would be more appropriate. There is no exclusionary context, so this is a 'no guidance' case rather than misleading.
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, the description bears full responsibility for behavioral disclosure, but it only states the action without explaining whether it permanently deletes credentials, is reversible, or impacts other site functions.
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 concise sentence, earning its place by stating the core action without waste. However, it is so brief that it omits important behavioral 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 that this is a destructive operation on WordPress credentials with no annotations or output schema, the description should provide more context about consequences and reversibility; it is under-specified.
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 already fully describes the single parameter (site_id) with 100% coverage, and the description adds no additional semantic information beyond the schema.
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 tool's function with a specific verb ('Disconnect') and resource ('WordPress from a site'), distinguishing it from sibling tools like save_wordpress_credentials and get_wordpress_status.
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, nor any prerequisites or context for disconnecting WordPress. The description is purely declarative with no usage instructions.
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, the description carries the full burden of disclosing behavior. It says 'Check' which implies a read operation, but it does not explicitly state that it is non-destructive, nor does it describe what the status output looks like or any error conditions. This minimal disclosure is insufficient for a tool with no annotation support.
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 concise sentence that fully captures the essence of the tool without unnecessary detail. Every word earns its place, making it optimally concise.
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 one-parameter tool, the description is minimally viable but lacks key context: it does not mention what the publish status represents (e.g., draft, published, pending), nor how it relates to the sibling get_wordpress_status. Given the absence of an output schema, this gap leaves the agent uncertain about the return value.
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 provides 100% coverage with a description for article_id ('Article ID'), and the tool description reinforces this with 'for an article'. No additional meaning is added beyond the schema, so 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 'Check WordPress publish status for an article' clearly states a specific verb and resource, and the scope 'for an article' distinguishes it from potentially broader tools like get_wordpress_status. However, it does not explicitly name that sibling tool to differentiate, so it falls short of 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?
No guidance is provided on when to use this tool versus alternatives such as get_wordpress_status or get_article. The description only states what it does, leaving the agent to infer usage context from the name alone.
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?
With no annotations, the description carries the full burden. It discloses that the tool validates the connection before saving, which is a key behavioral trait. However, it fails to mention side effects like overwriting existing credentials, failure behavior, or required permissions. The disclosure is partial but not misleading.
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 concise sentence that is front-loaded with the action. It avoids redundancy and every word adds value. It is appropriately sized for a simple tool, though it could be slightly more explicit without losing conciseness.
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 has no annotations and no output schema, the description is underspecified. It omits critical context such as what happens on failed validation, whether existing credentials are replaced, and what the response looks like. The validation hint is useful, but for a mutation tool with four required parameters, the description is not complete enough for an agent to invoke it 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?
The input schema provides 100% description coverage for all parameters, so the baseline is 3. The description adds minimal semantic context beyond the schema—only that this connects WordPress to a site, which loosely binds site_id, wp_url, and credentials. It does not elaborate on parameter formats or relationships, but schema already covers the basics.
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: 'Connect WordPress to a site', which is a specific verb plus resource. The added 'validates connection first' gives useful context. However, it does not explicitly distinguish from sibling tools like 'delete_wordpress_credentials' or 'get_wordpress_status', though the connection intent is clear.
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?
There is no explicit guidance on when to use this tool versus alternatives. The mention of 'validates connection first' implies a prerequisite (valid credentials) but does not state scenarios such as initial setup or updating credentials. No exclusions or alternative tool references 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?
With no annotations provided, the description carries the full disclosure burden. It only states that it creates an article and mentions the brief/custom source distinction; it does not disclose return value, required permissions, side effects, or whether it triggers content generation. For a mutation tool, this level of transparency 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 two short sentences, front-loaded with the action ('Create a new article') and free of filler. Every word contributes, making it appropriately concise for the information it conveys.
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 has 8 parameters, no output schema, and no annotations, the description is too sparse. It omits expected return behavior, other valid source types, and any context distinguishing this from generate_article or update_article. The schema richly covers parameters, but the overall behavioral context is incomplete.
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 coverage is 100%, so the parameters are already fully documented. The description adds the source_type=brief/source_id relationship and mentions the custom mode, but this information largely mirrors the schema's own descriptions. It does not add meaningful semantics beyond what the schema already provides.
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 uses a specific verb and resource ('Create a new article') and adds the source distinction (brief or custom), making the core purpose clear. However, it doesn't explicitly differentiate this from sibling tools like generate_article, and it omits several source_type enum values (growth_priority, content_gap, quick_win), which limits full differentiation.
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 when to use the tool ('Can be from a brief ... or custom'), which gives some contextual framing. It does not provide when-not-to-use guidance, alternative tool references, or clear exclusions, so the usage guidance remains implicit rather than 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the filtering parameters from the schema and does not mention return format, pagination behavior, or any side-effect-free guarantees, which are important for a list operation.
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, front-loaded sentence that immediately states the action and resource, followed by concise filter options. There is no redundancy or unnecessary detail.
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?
Despite 100% schema coverage, the absence of an output schema and annotations means the description must explain response structure and behavior. It doesn't mention what fields are returned, default pagination, or any caveats, leaving a notable gap for 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?
The input schema covers all six parameters with 100% description coverage, so the baseline is 3. The description summarizes some filters (site, status, signal type, search text) but adds no new meaning beyond what the schema already provides.
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 'List' and the resource 'editorial briefs', making the tool's purpose unambiguous. It also distinguishes itself from sibling tools like list_articles and get_brief, which serve 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?
The description provides no explicit guidance on when to use this tool versus alternatives. It doesn't mention scenarios where other tools would be more appropriate, nor any prerequisites 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what is generated but does not reveal whether the operation is asynchronous, how results are retrieved, whether repeated calls create duplicates, or any side effects. For a 'trigger' tool, this lack of behavioral detail 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 concise sentence with useful parenthetical clarification. Every word earns its place, and the verb is front-loaded. It avoids redundancy and is appropriately sized for a tool with one optional parameter.
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?
The tool is a simple trigger with no output schema, but the description still lacks important context: what the response contains, whether the synthesis runs synchronously, and how to check for results. Without annotations or an output schema, the description should provide more guidance on expected behavior, but it only offers a high-level outcome.
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% for the single optional parameter site_id, which is well-documented as 'Site ID to scope to (omit for all sites)'. Since the schema already explains the parameter, the description need not add more, and the baseline of 3 applies. The description does not complement or conflict with the schema.
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 tool's purpose with a specific verb ('Trigger') and resource ('brief synthesis'), and explains the outcome as 'generates editorial briefs from scraped content'. This distinguishes it from sibling tools like trigger_ingestion or trigger_profile by specifying the unique output (editorial briefs) and input source (scraped content).
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 does not mention prerequisites, sequencing relative to other trigger tools, or exclusions. The phrase 'from scraped content' only implies a precondition but offers no explicit 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, the description carries the full burden of behavioral disclosure. It only states the action 'Add' but does not mention side effects, duplicate handling, validation, or whether the addition is idempotent. This lack of detail is insufficient 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, front-loaded sentence with no filler or redundant information. Every word contributes to understanding the tool's purpose.
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 one-parameter add operation, the description is minimally adequate, but it lacks context about the account association, potential duplicate errors, or any follow-up behavior. Given the lack of annotations and output schema, a more descriptive explanation would improve completeness.
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 fully documents the 'email' parameter with a description ('Email address to add'), giving 100% coverage. The description adds only minimal context by labeling it as a 'delivery' recipient, which is a small enhancement but not significant beyond the schema.
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 ('Add') and the object ('delivery email recipient'), making the tool's purpose unambiguous. It distinguishes itself from sibling tools like list_account_emails and delete_account_email by focusing on the addition of a recipient.
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. While the name implies account-related email management, there is no mention of prerequisites, such as requiring an existing account, or when to use list_account_emails/delete_account_email instead.
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 provided, so the description must disclose behavioral traits. It only states 'Submit feedback' with no info about idempotency, overwriting previous feedback, required user context, or error conditions. It adds minimal context beyond the tool's purpose.
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?
Single sentence with prioritized action and list of values. No wasted 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?
Simple 2-parameter tool, but no output schema or annotations. Description covers purpose and allowed actions but omits behavioral outcomes, response, or whether feedback replaces existing. Adequate for basic invocation but leaves 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 covers 100% of parameters, so baseline is 3. The description repeats the enum values, adding slight clarity but no new semantics beyond schema. The schema descriptions are minimal, but the description doesn't explain format or dependencies.
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?
Description uses specific verb 'Submit feedback' and identifies the resource 'a brief', enumerating all four accepted actions. It clearly differentiates from sibling tools like list_briefs or get_brief, which are read operations, by indicating a write/feedback action.
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 on when to use this tool vs alternatives. It doesn't mention prerequisites (e.g., brief must exist) or exclude scenarios. The enum values imply feedback context but don't provide explicit 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 responsibility for behavioral disclosure. It only says 'Delete' and does not mention whether the deletion is permanent, requires special permissions, or has side effects on related data such as RAG indexes.
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, front-loaded sentence that states the action and resource without any filler or redundant information. It is appropriately sized for a simple one-parameter tool.
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?
The tool is simple with one parameter, but without annotations or an output schema, more context would be helpful—such as whether the deletion is reversible or what the response contains. The current description is minimal but not entirely inadequate.
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 already covers the single parameter doc_id with 100% description coverage ('Corpus document ID'). The description's 'by ID' adds no meaningful semantic detail beyond what the schema provides, so the baseline 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 action ('Delete'), the resource ('corpus document'), and scope ('single ... by ID'), distinguishing it from sibling delete tools like delete_article and delete_source.
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, nor any prerequisites or context. It simply states what it does without placement among 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?
With no annotations, the description carries the full burden. It implies a read-only detection operation but doesn't explicitly state that it doesn't modify data, nor does it disclose error behavior for invalid URLs, redirects, or network failures. The phrase 'auto-detect' is too vague to inform the agent of potential side effects or failure modes.
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?
A single, front-loaded sentence clearly communicates the tool's purpose with no redundant words. It is appropriately concise.
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?
The tool is simple (1 parameter, no output schema, no annotations). The description covers the core purpose and implied output, but it omits important context like whether a valid URL is required, what happens on failure, and whether the operation is safe (read-only). For a tool with no annotations and no output schema, this leaves notable 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 schema already provides 100% description coverage for the 'url' parameter. The description reinforces that the tool works 'from a URL' but adds no additional format, validation, or usage details beyond the schema. Baseline 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 uses the specific verb 'detect' and clearly identifies the resource as 'source type and feed URL' from a URL. This distinguishes it from sibling source tools like list_sources and get_source which operate on existing sources.
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 about when to use this tool versus alternatives. For example, it doesn't mention that this is useful before adding a source or that it should be used only for URLs not yet in the system. There is no 'use when' or 'instead of' context.
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, the description carries the full burden. It implies a read operation via 'Get' but does not disclose output format, potential computational cost, or any side effects. It also doesn't clarify whether the report is precomputed or generated on demand.
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?
A single sentence with no filler, directly front-loaded with the action and resource. It is highly efficient 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?
The tool is simple with one parameter, but the description relies on domain jargon ('brief-vs-corpus coverage') without explaining what the report contains. It is minimally sufficient for invocation but leaves ambiguity about the output's meaning and format.
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 fully documents the only parameter ('site_id' with 'Site ID' description), so the description adds no extra meaning. This meets the baseline for high schema coverage, as the schema already provides sufficient parameter information.
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 uses a specific verb ('Get') and identifies a distinct resource ('brief-vs-corpus coverage report') scoped to a site. It clearly differentiates from the sibling 'get_coverage_explore' by focusing on the report itself rather than exploration.
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 'get_coverage_explore' or 'rag_stats'. It only states the action without context, exclusions, or alternative recommendations.
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 the type of data returned but does not state whether the operation is read-only, any prerequisites, potential side effects, or authorization requirements. This leaves 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, well-structured sentence that front-loads the verb and resource, then lists the data types. Every word contributes useful information, with no fluff or repetition.
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 has one parameter, no output schema, and no annotations, the description summarizes the return data but lacks context about the data structure, edge cases, or usage constraints. It is minimally adequate but not rich enough to fully guide an agent without further inference.
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 already documents site_id with a description ('Site ID'), and schema coverage is 100%. The description adds no additional meaning about the parameter, so a 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 tool's purpose: to get Topic Explorer data, and enumerates specific data types returned (entity clusters, coverage status, traffic, action cards). This distinguishes it from siblings like get_coverage, which likely provides a simpler coverage view.
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 get_coverage. The description does not mention any specific conditions or exclusions, leaving the agent to infer usage from the name and basic description.
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, the description must carry full behavioral disclosure. It only says 'Check', implying a read-only operation, but does not describe what 'status' includes, whether authentication is needed, possible error behaviors, or the response format. This is minimal disclosure beyond the action itself.
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, concise sentence with no redundant words or information. It is front-loaded 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?
The tool is simple with one parameter, but for a status check with no output schema, the description does not explain what the response will contain (e.g., connected/disconnected, details). This is a notable gap, but acceptable for a very simple 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% for the sole parameter site_id, so the schema already fully documents it. The description adds no extra semantic context, matching the baseline of 3.
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 ('Check'), the resource ('WordPress connection status'), and the scope ('for a site'), making it distinct from sibling tools like get_publish_status or save_wordpress_credentials. No ambiguity.
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, such as get_publish_status for article publishing status. The context is only implicit in the name, and no exclusions or alternative references are given.
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, the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but the description does not clarify return format, time range behavior, pagination, or any required permissions. The term 'daily' hints at aggregation granularity but lacks detail.
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, front-loaded sentence with no wasted words. It conveys resource, granularity, and purpose efficiently.
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?
The tool has only one parameter and no output schema, so the description is the primary source of return-value context. It states the general output ('daily GSC performance metrics') but omits specifics like metric names, date ranges, or response format. This is adequate but not fully complete for a data-fetching 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 for site_id, so the baseline is 3. The description adds no further meaning about site_id beyond identifying the site context, but the schema description is sufficient for a single simple 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 uses a specific verb ('Get'), a clear resource ('daily GSC performance metrics'), and an explicit use case ('for sparklines and trends'). This distinguishes it from similar sibling tools like gsc_summary and gsc_queries by emphasizing daily granularity and chart/trend usage.
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 phrase 'for sparklines and trends' implies a use case, but the description does not explicitly state when to use this tool versus alternatives such as gsc_summary or gsc_queries. There are no exclusions or alternative tool references, leaving selection ambiguous.
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, the description carries the full burden of behavioral disclosure. It does not explain how 'losing clicks/impressions over time' is determined (e.g., time window, thresholds, calculation method), nor does it mention any permissions, limitations, or output format. The description is too sparse to provide meaningful transparency.
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, concise sentence with no wasted words. It is front-loaded with the verb and resource. However, it omits potentially useful context like time range parameters, but given its brevity, it remains efficient and structured.
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 simple one-parameter tool, the description provides only the basic idea. It lacks details about how 'over time' is defined, what the output includes (e.g., query names, metrics, change percentages), and how it relates to sibling tools. Given no output schema and no annotations, the description is insufficient for an agent to fully understand the tool's behavior and response.
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 one parameter (site_id) with 100% description coverage, so the baseline is 3. The description adds no additional meaning about the parameter beyond its existing 'Site ID' description, but since the schema already fully documents it, no further compensation is needed.
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 tool's purpose: 'Get GSC queries losing clicks/impressions over time.' It uses a specific verb 'Get' and resource 'GSC queries' with a distinguishing qualifier ('losing clicks/impressions over time') that separates it from siblings like gsc_growing_queries and gsc_queries.
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 identifying declining queries but does not explicitly state when to use this tool versus alternatives such as gsc_queries or gsc_growing_queries. No when/when-not guidance or alternative mentions are provided, so it relies on the user to infer from the name and description.
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 only states the action and optional filtering, but does not mention that this is a read-only operation, default pagination behavior, or what fields are returned for each document.
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, concise sentence that is front-loaded with the primary action and resource. Every word earns its place, with no filler or repetition.
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 simplicity of the tool and good schema coverage, the description is minimally adequate. However, it lacks mention of return format or pagination specifics, and does not position itself against search_rag, which may be relevant for filtering scenarios.
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 coverage is 100% with descriptions for all three parameters (limit, offset, hostname). The description adds no additional semantic value beyond what the schema already states, particularly for the hostname filter.
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') and the resource ('RAG corpus documents'), with an optional filter ('by hostname'). It distinguishes itself from siblings like delete_corpus_document and search_rag by being specifically about listing corpus documents.
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 given on when to use this tool versus alternatives such as search_rag or list_articles. The description provides no exclusions or explicit context, leaving the agent to infer usage purely from the tool name.
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. It discloses that plan limits apply, which is useful, but it does not mention return values, idempotency, error handling, permissions, or potential side effects. The single sentence leaves most behavioral aspects undocumented.
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 one sentence, front-loaded with the verb, and contains no redundant words. It is appropriately sized for a simple create tool.
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 absence of an output schema and annotations, the description does not specify what the agent should expect after creation (e.g., the created site object or success message), nor does it address potential errors or prerequisites beyond plan limits. For a simple tool, it is minimally sufficient but has clear gaps in outcome and failure behavior.
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 already documents the only parameter 'url' as 'Site URL' (100% coverage), so the description adds no new parameter information. No format, uniqueness, or validation details are provided beyond the schema. The baseline of 3 is appropriate since the schema does the heavy lifting.
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 uses the specific verb 'Create' and identifies the resource 'site', clearly stating the action. It distinguishes from sibling tools like list_sites, update_site, and delete_site by focusing on creation. The parenthetical 'subject to plan limits' adds a relevant constraint without confusing the purpose.
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 (creating a site) but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The plan-limit note hints at a condition but doesn't explain how to handle it or when to avoid the tool. Usage is inferred from the name and verb rather than stated.
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?
With no annotations, the description carries the transparency burden. It discloses that the operation is a queue (async) and returns immediately, which is a key behavioral trait. However, it does not describe the return value, error conditions, or side effects (e.g., does it overwrite existing drafts?), leaving 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 concise sentence that front-loads the purpose and includes a key behavioral note ('Returns immediately'). Every word earns its place, with no redundant or filler content.
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?
For a simple one-parameter async tool, the description covers the main action and behavior. It lacks details on what the immediate return is (e.g., a job ID) and how to check status (e.g., get_article or get_draft), but given the low complexity and rich sibling set, it is reasonably complete.
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 the only parameter. The description adds no additional meaning about 'article_id' beyond what the schema provides, meeting the baseline without extra 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 uses a specific verb ('Queue') and resource ('article for AI generation') with scope (research, outline, draft, voice check), clearly stating the tool's function. While it doesn't explicitly distinguish from the sibling 'generate_draft', the broader pipeline context makes the purpose reasonably clear.
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 explicit guidance on when to use this tool versus alternatives such as generate_draft or regenerate_article. The phrase 'Returns immediately' implies asynchronous usage, but there is no exclusions, alternatives, or context about prerequisites (e.g., whether the article must exist).
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 only states the action without disclosing return format, date range handling, sorting, or limits. Having no behavioral detail for a tool that could have multiple interpretations of 'losing search performance' is a 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, concise sentence with the verb and object front-loaded. No wasted words.
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?
Although the tool has only one parameter, the description lacks essential context: what the output looks like, how 'declining' is defined, what time horizon is considered, and whether results are sorted. With no output schema to compensate, this is incomplete for an agent to anticipate behavior.
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 coverage is 100% with site_id described as 'Site ID'. The description adds no parameter-specific context, but the schema already covers the only parameter, reaching the baseline of 3.
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 uses a specific verb 'Get' and defines the resource as 'pages losing search performance over time,' clearly distinguishing it from sibling tools like gsc_declining_queries (which focuses on queries) and gsc_growing_pages (the opposite trend).
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 purpose implies usage for declining page performance, but there is no explicit guidance on when to use this tool vs alternatives, or any exclusions. It is left to the agent to infer from the sibling tool names.
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, the description carries the full burden of behavioral disclosure. It mentions gaining clicks/impressions over time but does not define the time window, growth threshold, output format, pagination, or limits. This leaves significant ambiguity about what the agent should expect when invoking the 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, front-loaded sentence that communicates the core purpose with zero wasted words. Every word contributes to the meaning, making it an example of efficient structure.
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?
Despite the low parameter count, the description omits crucial context such as the precise definition of 'growing', the default time range, and the expected response structure. With no output schema or annotations, the agent cannot infer these details, and the description is incomplete relative to its complexity and the presence of many similar GSC sibling tools.
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 only parameter, site_id, is fully described in the schema as 'Site ID', giving 100% schema coverage. The description adds no additional parameter-level detail, but the high schema coverage justifies the baseline score of 3.
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 identifies the action (get), resource (GSC queries), and a distinctive qualifier ('gaining clicks/impressions over time') that distinguishes it from sibling tools like gsc_declining_queries and gsc_queries. The verb+resource combination is specific and 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 its use case—for queries trending upward in clicks or impressions—but it does not explicitly state when to prefer this tool over alternatives like gsc_queries or gsc_opportunities, nor does it mention exclusions or prerequisites. This makes usage guidance only partially explicit.
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?
With no annotations, the description carries the burden of disclosing behavior. The verb 'list' implies a read-only operation with no side effects, which is clear. However, it does not add details such as whether authentication is required, if the list is sorted, or whether it returns only email addresses or additional metadata. The core behavior is transparent, but additional context is missing.
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 one short sentence of five words, conveying the essential action and target with no redundancy or irrelevant information. Every word earns its place, 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 low complexity (zero parameters, no output schema, no annotations), the description covers the core purpose adequately. However, it does not specify what the return value looks like (e.g., a list of email addresses, objects, etc.) or any additional context about the delivery email recipients, so it is slightly incomplete but sufficient for a simple list tool.
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 zero parameters, and the schema has 100% coverage (i.e., no properties). According to the rubric, a baseline score of 4 is appropriate when there are no parameters, as there is no param information to convey. The description correctly avoids inventing 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 'List delivery email recipients' uses a specific verb (list) and identifies the resource (delivery email recipients), clearly indicating the tool's function. However, it does not explicitly distinguish from the sibling tool 'list_deliveries', which could also be related to emails, so it lacks some 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 does not mention that this is the read counterpart to add_account_email/delete_account_email, nor does it clarify the relationship with list_deliveries. No exclusions or specific context are given.
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 present, so the description carries the full burden. It only says 'List all content sources' and 'Optionally filter by site', which implies a read-only operation but does not disclose pagination, response structure, or other behavioral traits. Minimal context is added beyond the name.
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 short sentences front-loaded with the core purpose and a clear optional parameter. No wasted words.
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?
For a simple list tool with one optional parameter and no output schema, the description conveys the core functionality and filter capability. However, it does not mention pagination, ordering, or return structure, which would be useful in the absence of an output schema. Given the low complexity, it is reasonably complete.
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% (site_id has a description). The description echoes the optional filter but adds little beyond the schema. The baseline of 3 applies because the schema already documents the parameter effectively.
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 uses the specific verb 'List' and the resource 'content sources', clearly distinguishing it from sibling tools like get_source (which retrieves a single source) and list_articles (a different resource type). The optional site filter adds precision.
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 only states the action and an optional filter, without mentioning when to prefer list_sources over list_sites or get_source.
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 only states the action and source but does not explain what populating entails (e.g., whether it overwrites existing content), whether authentication or permissions are needed, or what the result/output will be. This is a significant gap for a mutating operation.
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, front-loaded sentence that conveys the core purpose without unnecessary words. It is appropriately sized and every word contributes to the meaning.
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?
The tool has no output schema and no annotations, so the description needs to explain what happens when the tool is invoked and what the caller can expect in return. It does neither. For a mutation tool with potential side effects (populating a corpus), this is incomplete.
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 provides 100% coverage with descriptions for both 'hostname' and 'max_pages'. The description itself does not add parameter-level detail, but the schema already documents the parameters adequately, so the baseline 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 action ('Populate') and the target resource ('corpus') with a specific source method ('from a website sitemap'). This distinguishes it from sibling tools like populate_youtube and populate_corpus by specifying the input source.
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 when to use the tool: when you want to populate the corpus from a website sitemap. However, it does not explicitly state when not to use it or mention alternative tools such as populate_corpus or populate_youtube, so usage guidance remains implicit rather than 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 must disclose behavioral traits itself. It indicates a write operation ('Update') but does not mention any prerequisites, potential side effects, idempotency, validation behavior, or what happens if the site_id does not exist. The description offers no additional behavioral context beyond the action itself.
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, focused sentence that effectively communicates the tool's purpose. It is front-loaded with the action verb and resource, contains no redundant words, and is appropriately concise for a simple update operation.
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?
The tool has a low complexity (3 flat parameters, no nested objects, no output schema), but the description only covers the basic purpose. It fails to mention that the name and URL are optional, that only site_id is required, or what happens on success/failure. Given it is a mutation tool without annotations, the description should provide more behavioral context to be fully complete.
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 already provides descriptions for all three parameters, giving 100% coverage. The description mentions 'name or URL' which aligns with the schema but adds no extra semantic detail beyond what is already specified. The baseline of 3 is appropriate since the schema does the heavy lifting.
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 ('Update') and the resource ('a site'), and specifies the exact attributes being updated ('name or URL'). This directly distinguishes it from sibling tools like update_site_schedule, which updates a different aspect.
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 the usage context: use this tool when you need to change a site's name or URL. However, it provides no explicit guidance on when not to use it or alternatives (e.g., update_site_schedule for schedule changes). The usage is clear but not elaborated.
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 must carry the full burden of behavioral disclosure. It only states that the tool adds a source, with no mention of side effects, permission requirements, duplicate handling, validation, 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, front-loaded sentence with no filler. It communicates the core action and supported types in a compact format, earning its place with every word.
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 create tool with no output schema and basic annotations, the description covers the main purpose adequately. However, it omits the optional site_id parameter's role in attaching the source to a site, and does not mention any return values or validation behavior, leaving some context incomplete.
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 baseline is 3. The description adds some value by listing source types, which enriches the 'type' enum, but it does not explain the meaning of url, name, or site_id beyond what the schema already provides. It neither significantly compensates nor degrades from the schema.
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 uses a specific verb ('Add') and resource ('content source'), and enumerates the supported source types (RSS, YouTube, Reddit, podcast, news). This clearly distinguishes it from sibling tools like update_source, delete_source, or list_sources.
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 the tool is used when you need to add a new content source, but it provides no explicit guidance on when to use it versus alternatives, nor any exclusions or prerequisites. It gives context about what types are supported but no direction on choosing this tool over others.
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?
With no annotations, the description carries the burden. It discloses that content items are also removed, but doesn't mention irreversibility, permissions, or what exactly constitutes content items (articles, briefs, etc.).
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?
Single sentence, front-loaded verb, no wasted words. Highly concise and structured appropriately.
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 one-param delete tool, the description is adequate but minimal. Lacks clarity on permanence, cascading scope of 'content items', and any preconditions. With no annotations or output schema, it could benefit from more 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 coverage is 100% (source_id with description 'Source ID to delete'), so baseline 3 applies. Description adds no additional parameter details beyond schema.
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?
Description uses specific verb 'Remove' and resource 'content source' with explicit scope 'and its content items', distinguishing it from sibling delete tools like delete_article and delete_brief by clarifying the cascading effect.
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 on when to use this tool vs alternatives like update_source or delete_article. No prerequisites, cautions, or alternative tool suggestions.
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 must fully disclose behavioral traits. However, it only states the action with no details about side effects (e.g., whether existing corpus data is replaced), required permissions, or the nature of the ingestion. For a mutation tool, this is a significant transparency 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?
A single, front-loaded sentence that communicates the core purpose without filler. Every word 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?
The tool is simple with only two documented parameters and no output schema, so a brief description is defensible. However, it fails to clarify that the two parameters are likely alternatives (either feed_url or channel_id can be used), and it does not cover behavioral expectations despite being a mutation with no annotations. This leaves moderate gaps given the tool's simplicity.
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%: both feed_url and channel_id already have descriptive definitions. The description adds no extra meaning beyond what the schema provides, so a baseline 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?
Description uses a specific verb ('Populate'), names the resource ('corpus'), and specifies the source ('YouTube channel') with a clarifying parenthetical about transcripts. This clearly distinguishes it from sibling tools like populate_corpus and populate_site, which would operate on different source types.
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 the user wants to ingest YouTube transcripts into the corpus, but does not explicitly state when not to use it or name alternative tools. It offers no exclusion criteria or comparisons with sibling populate functions, so guidance is only implicit.
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, the description carries the full burden of behavioral disclosure. It mentions the credential requirement but does not explain side effects (e.g., article becoming publicly visible), reversibility, error behavior, or what the response indicates. 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 sentence that front-loads the action and target, appends a key prerequisite, and contains no filler words. It is appropriately sized for a one-parameter tool.
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 one-parameter publish action, the description covers the core action and a prerequisite, but it omits return behavior, success/failure semantics, and any guidance on typical workflow ordering. It is minimally viable but lacks contextual richness that would help an agent use it confidently without further exploration.
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 already documents article_id with 100% coverage, establishing a baseline of 3. The description adds meaning by specifying that the article must be a 'generated article', which constrains the valid article_id beyond the schema's generic 'Article ID to publish'.
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 uses a specific verb ('Publish') and resource ('a generated article to WordPress'), clearly distinguishing it from siblings like generate_article, get_article, and get_publish_status. The target platform (WordPress) adds useful scope.
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?
It gives one prerequisite ('requires WP credentials on the site') but does not state when to use this tool versus alternatives, such as checking publish status with get_publish_status or updating an article before publishing. No exclusions or alternative tool references 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 the full burden. It merely states 'Regenerate a failed or completed article' without disclosing whether this overwrites the existing article, what happens to the current version, or any side effects. There is no mention of idempotency, permissions, or return behavior. This is a significant gap for a mutation-like tool.
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 short sentence, which is concise and front-loaded. It contains no fluff or redundant words. However, it is arguably too terse, lacking critical behavioral context, but for what it says, it is efficient. I give it a 4 because while it is not verbose, it is not fully 'appropriately sized' given the missing information.
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?
With no output schema, no annotations, and only one parameter, the description is the only source of context. It does not explain the regeneration process, what the endpoint returns, when it is appropriate to call it relative to other generation tools, or any constraints. For a tool with many siblings, this is insufficient for an agent to select and invoke it correctly.
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 has full coverage for the single parameter (article_id) with a description 'Article ID to regenerate'. The tool description adds no additional meaning beyond the schema, so the baseline 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 uses a specific verb ('Regenerate') and identifies the resource ('article') with a clear status qualifier ('failed or completed'). This distinguishes it from sibling tools like generate_article, which would create a new article. The purpose is immediately understandable.
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 when to use the tool: when an article is 'failed or completed'. This provides clear context for re-running generation. However, it does not explicitly mention alternatives or exclusions, such as 'use generate_article for new articles', so it loses one point.
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 only states 'fetches new items' but does not explain whether the operation is asynchronous, what side effects occur (e.g., database writes, network calls), or if any confirmation is returned. For a trigger-type tool, this is a significant transparency 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 sentence that front-loads the action and resource, with the parenthetical adding useful context. Every word contributes to understanding, with no unnecessary filler.
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 (one optional parameter, no output schema), the description is minimally sufficient to convey its core function. However, it lacks details about the asynchronous nature, return behavior, or what 'ingestion' entails, leaving some context gaps for 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 one parameter, source_ids, with a description ('Specific source IDs (omit for all)') covering 100% of the schema. The tool description adds no extra parameter-level detail, so 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 tool's purpose: 'Trigger content ingestion' with the parenthetical clarifying it fetches new items from specific source types. This distinguishes it from sibling trigger tools like trigger_profile and trigger_synthesis, which have different actions and resources.
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 the tool should be used to initiate fetching of new content from external sources, but it does not explicitly state when to prefer it over alternatives or provide any context on prerequisites. No exclusions or alternatives 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 indicates a mutation ('update') but does not mention permissions, side effects, reversibility, or how unspecified fields are handled. The parenthetical operation list is minimal and does not explain whether keyword filters are replaced or merged.
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 sentence that front-loads the primary verb and resource, with a parenthetical clarifying the two operation types. Every word contributes to meaning, with zero filler.
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 mutation tool with complete schema coverage but no annotations or output schema, the description provides the essential purpose but lacks context about prerequisites, effects on existing data, or when to choose this tool over siblings. The schema compensates for parameter semantics, but the description does not add behavioral or usage 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?
The schema provides full descriptions for all parameters (100% coverage), meeting the baseline of 3. The description adds a high-level mapping between 'name' and 'rename' and 'keywords' and 'keyword filters', but does not add detail beyond the schema.
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 'update' and resource 'source', and specifies the two operations: 'rename or set keyword filters'. This distinguishes it from sibling tools like add_source, delete_source, and get_source.
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 modifying an existing source, but does not explicitly mention when to use it versus alternatives such as add_source or delete_source. There is no explicit when-to-use guidance or exclusions, so it relies on the name and basic context.
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. It mentions 'syncs GSC, runs analysis', which gives some behavioral hint, but it does not disclose whether the operation is asynchronous, destructive, requires credentials, or what side effects occur (e.g., creating a stored plan). The description lacks critical behavioral details for a generation 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 sentence with a parenthetical aside, conveying the core action and key sub-steps efficiently. Every word earns its place, with no redundancy or filler.
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?
The tool has a single parameter but performs a complex operation (sync, analysis, generation). With no output schema and no annotations, the description should at least hint at return values, duration, or side effects. The minimal details leave the agent uncertain about what to expect after 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?
The input schema already provides 100% coverage for the single parameter (site_id with a clear 'Site ID' description). The tool description adds nothing beyond the schema's parameter definition, so baseline 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 uses a specific verb 'Generate' with resource 'growth plan' and adds process detail ('syncs GSC, runs analysis'), clearly distinguishing it from 'get_growth_plan' which retrieves an existing plan. It unambiguously states what the tool does.
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 clearly implies the tool is used to create a new growth plan for a site, and the parenthetical hints at the workflow. However, it does not explicitly contrast with sibling tools like get_growth_plan or gsc_sync, nor does it state when not to use it. The context is clear but exclusions are missing.
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?
With no annotations provided, the description carries the full burden. It does disclose the output components (markdown, outline, research, provenance) which adds value beyond the name. However, it does not explicitly state read-only nature, permissions, or potential error conditions, though the verb 'Get' implies a safe read operation.
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, front-loaded sentence that efficiently conveys the tool's purpose and key output components without unnecessary words.
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?
For a simple getter with one parameter and no output schema, the description is mostly complete, listing what the returned article includes. However, it does not explain how it relates to sibling tools such as get_article_provenance, which might cause confusion, but overall the essential content is sufficient.
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 one parameter with a description, and schema coverage is 100%. The description does not add any extra meaning about the article_id parameter beyond what the schema already provides, so the baseline score of 3 applies.
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 tool gets full article detail, specifying the included components (markdown, outline, research, provenance). This is a specific action and resource that naturally distinguishes it from sibling tools like get_draft or get_article_provenance.
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?
There is no guidance on when to use this tool versus alternatives such as get_draft or get_article_provenance. The description merely states what it does without indicating usage context or exclusions.
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?
With no annotations, the description must carry the behavioral burden. It discloses the content of the response (per-section facts, sources, entity QIDs, JSON-LD), which is useful, but does not mention whether it is read-only, requires special permissions, or how errors are handled.
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?
One sentence, front-loaded with the main purpose and a concise list of contents. No filler or redundancy.
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?
For a simple get operation with one parameter, the description adequately covers the purpose and output contents. However, the absence of annotations and output schema leaves some gaps about return structure, but the listed components provide a reasonable overview.
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 single parameter article_id is fully described in the schema ('Article ID'). The tool description adds no extra semantic information about the parameter, so this is a baseline score for complete 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 uses a specific verb 'Get' and identifies a clear resource ('full provenance chain') with enumerated components (per-section facts, sources, entity QIDs, JSON-LD). This distinguishes it from siblings like get_article or list_sources.
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 get_article or list_sources. The description simply states what it does, leaving the agent to infer usage context.
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, the description carries the full burden of disclosure. It provides no information about side effects, error conditions (e.g., if no draft exists), or whether this is a read-only operation. The description is purely functional and lacks behavioral context.
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, front-loaded sentence with no unnecessary words. It immediately states the action and target, achieving maximum clarity with minimal length.
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?
For a simple one-parameter getter, the description covers the core purpose adequately. It does not explain return format or behavior when a draft is missing, but given the tool's simplicity and lack of output schema, the description is largely sufficient for an agent to understand its role.
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 already describes brief_id as 'Brief ID' with 100% coverage. The description reinforces that the draft is for that brief but adds no additional semantic detail beyond the schema. 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 uses a specific verb ('Get') with a clear resource ('generated draft text') and target ('for a brief'). It clearly distinguishes itself from siblings like generate_draft (which creates) and get_brief (which retrieves brief metadata).
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 that this tool is used to retrieve a draft after generation, but it does not explicitly state when to use it versus alternatives or mention prerequisites like calling generate_draft first. No exclusionary guidance is provided.
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?
With no annotations, the description carries the full burden. It implies a read-only operation via 'Get' but does not add behavioral context such as data freshness, caching, or precondition requirements. This is adequate for a simple retrieval tool but lacks depth.
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, front-loaded sentence that includes essential specifics (28-day, metrics). It is concise and contains no extraneous information.
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?
For a simple tool with one parameter and no output schema, the description lists the metrics returned (clicks, impressions, CTR, position), effectively conveying the response content. It could be more comprehensive by noting data computation or freshness, but is largely complete for its simplicity.
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 single parameter site_id is fully described in the schema ('Site ID'), so the description adds no additional meaning. Per guidelines, the baseline is 3 when schema coverage is high, and no extra value is provided.
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 tool's purpose with a specific verb ('Get'), resource ('GSC performance summary'), and scope ('28-day clicks, impressions, CTR, position'). This distinguishes it from related tools like gsc_queries and gsc_daily_summary by focusing on aggregate summary metrics.
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 such as gsc_queries, gsc_daily_summary, or gsc_opportunities. The description only states what it does, without any context for selection or exclusions.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context by noting the use of the site profile voice guide, but it does not describe side effects, return behavior, or whether it creates a persistent draft. The description is informative but incomplete for a generation 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, concise sentence (13 words) that front-loads the primary action and includes a parenthetical clarification. There is no unnecessary information or repetition.
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?
The tool is simple with one parameter, but there is no output schema or description of return values. The description explains the core purpose but leaves ambiguous whether the draft is returned directly or must be retrieved separately (e.g., via get_draft). This gap reduces completeness.
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 coverage is 100% since the only parameter (brief_id) has a description. The description adds minimal semantic value by clarifying the brief is used for the draft, but it does not provide additional detail beyond the schema. Baseline of 3 is appropriate given full 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 tool's function: 'Generate a voice-matched draft article for a brief.' It uses a specific verb (generate), identifies the resource (draft article), and adds a distinguishing qualifier (voice-matched). This effectively differentiates it from sibling tools like generate_article or regenerate_article.
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 the tool is used when generating a draft from a brief, but it does not explicitly state when to use it versus alternatives or provide exclusions. Context is present ('for a brief'), but there is no direct comparison to sibling tools or guidance on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits. It adds the useful fact that the plan is 'cached', implying possible staleness, but does not disclose what happens if no cached plan exists, authentication requirements, or any side effects. This is a read-only operation, but the description remains minimal.
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 concise sentence, 'Get the latest cached growth plan for a site', with no redundant words or vague elaboration. Every word contributes to the meaning.
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 getter with only one parameter and no output schema, the description gives the core purpose, but it lacks information about the return format, what a growth plan contains, or failure behavior when no cached plan exists. Given the simplicity, this is adequate but 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?
Schema coverage is 100% (site_id described as 'Site ID'), so the schema already fully documents the parameter. The description adds no additional meaning beyond aligning 'for a site' with the site_id parameter. Baseline 3 applies.
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 (get), the resource (latest cached growth plan), and the scope (for a site). It distinguishes itself from the sibling generate_growth_plan by emphasizing 'cached', making clear this retrieves an existing plan rather than creating one.
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 usage context is implied: 'latest cached' suggests retrieval rather than generation, but there is no explicit statement about when to use this tool versus alternatives like generate_growth_plan, nor any exclusions or prerequisites.
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 full behavioral disclosure. It implies a read-only operation via 'Get' and lists the statistics returned, but does not explicitly state side-effect-free behavior or output structure. It adds some value by specifying the items, but lacks depth.
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 sentence, front-loaded with the action, and contains no filler. Every word adds value, 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?
The tool has no output schema and no annotations, so the description must fully explain the result. It lists three statistics but does not describe the output format or clarify potential ambiguities (e.g., what 'coverage' means). It is adequate for a simple tool but leaves some gaps.
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 zero parameters, so the description does not need to explain parameter semantics. Baseline for 0 params is 4, and no additional parameter information is required.
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 a specific verb ('Get') and resource ('RAG corpus statistics') and enumerates the content (document counts, hostnames, coverage), distinguishing it from sibling tools like list_corpus_documents and get_coverage.
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 choose this tool over alternatives. It does not mention exclusions or compare to related RAG tools, such as get_coverage or search_rag.
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?
With no annotations, the description carries the disclosure burden. It does reveal the core workflow (scraping sitemap, analyzing content) and the cache-bypass behavior for force=true. Still, it omits side effects such as whether an existing profile is overwritten, whether execution is asynchronous, or any permission/rate-limit implications.
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?
Three short sentences, each earning its place: the first states the purpose, the second describes the process, and the third highlights the key optional parameter. It is front-loaded and free of fluff.
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 must carry more weight. It conveys the tool's action and cache behavior, but does not state what the caller receives (if anything), whether the operation is long-running, or any required setup like having the hostname already registered. These gaps leave the description adequate but not complete.
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 baseline is 3. The description adds only a redundant callout to 'force=true' and does not elaborate on hostname semantics beyond the schema's own parameter descriptions.
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 uses a specific verb-resource pair ('Generate/refresh a site profile') and elaborates with concrete behavior ('Scrapes sitemap, analyses content'). This distinguishes it from sibling tools like get_profile, which retrieves an existing profile, and trigger_ingestion/trigger_synthesis, which target 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a site profile needs to be created or updated, and the 'Use force=true to bypass cache' instruction offers practical invocation guidance. However, it does not explicitly state when to prefer this over alternatives, nor does it mention exclusions or prerequisites beyond the cache behavior.
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 burden. It discloses the key behavioral trait of permanence, but does not mention side effects, permissions, rate limits, or response behavior. For a simple delete, this is adequate but minimal.
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 sentence with zero wasted words. It is front-loaded with the verb and resource, making it immediately clear.
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?
For a simple 1-parameter tool with no output schema, the description is reasonably complete. It conveys the action and permanence, though it could optionally mention what happens on success (e.g., confirmation) or if deletion is asynchronous.
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 covers 100% of parameters (article_id is described as 'Article ID'), and the description adds no parameter-specific detail. Thus the baseline of 3 for high schema coverage applies.
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 what the tool does: 'Permanently delete an article' uses a specific verb and resource, and distinguishes from siblings like update_article or publish_article. The 'permanently' qualifier adds clarity about irreversibility.
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—delete an article when you need to remove it permanently—but provides no explicit guidance on when to use this versus alternatives like unpublishing or updating. It does not mention exclusions or context.
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?
With no annotations provided, the description carries the transparency burden. It discloses the return contains synthesis, enrichment, signals, and keywords, but does not mention read-only behavior, error handling, or any side effects. The verb 'get' implies a safe read operation, but lacks explicit behavioral detail.
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, front-loaded sentence that directly states the tool's function and key output contents. Every word adds value, with no filler or redundancy.
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?
For a simple get-by-ID tool with one param and no output schema, the description adequately explains what the tool returns. It could mention the format or structure of the detail, but the list of included components provides sufficient context for the tool's complexity.
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 'brief_id' parameter already described as 'Brief ID'. The tool description adds no additional meaning or usage detail for the parameter, so it meets the baseline but does not exceed it.
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 'Get full brief detail including synthesis, enrichment, signals, and keywords' clearly identifies the tool as fetching detailed brief data and lists specific component categories. This distinguishes it from siblings like list_briefs (which likely returns summaries) and delete_brief, 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 needing the full brief content but does not explicitly state when to use this tool over alternatives. No exclusions or specific complementary tools are mentioned, leaving the usage context only implicitly defined.
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 implicitly signals a read-only operation via 'Get' and usefully describes what the profile contains, but does not disclose error handling, authentication requirements, or whether the data is live or cached. Some behavioral context is present, but key traits are missing.
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?
A single, well-structured sentence that front-loads the action and resource, includes a clarifying example scope, and has zero filler. Every word earns its place.
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?
For a simple one-parameter getter with no output schema, the description adequately conveys the tool's purpose and return contents. It lacks explicit response format or error behavior, but given the low complexity, it is reasonably complete.
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%, and the single parameter 'hostname' already includes an example. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and clear resource ('site profile'), with qualifiers ('by hostname') and a parenthetical listing the profile contents (voice, topics, audience, style guide). This clearly distinguishes it from sibling get_* tools like get_source or get_article.
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?
Usage is implied: when you need a site profile for a given hostname, use this tool. However, it does not explicitly state when not to use it or mention alternatives, leaving some ambiguity for an AI agent navigating many similar get_* tools.
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 must convey behavior. It indicates a read-only listing operation by the verb 'list', which is clear. However, it does not mention pagination, default limit (despite the schema having it), or what fields are returned. It is not misleading but lacks depth.
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 sentence with no wasted words, quickly conveying the tool's purpose. It is optimally concise and front-loaded.
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?
For a simple listing tool with full parameter documentation in the schema and no output schema, the description is adequate. It covers the core behavior and the primary filter. It would benefit from a mention of default limit or return format, but given the schema covers the limit parameter, this is a minor gap.
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 already describes all parameters with 100% coverage, including the status filter and limit default. The description only mentions the status filter as optional, which is already implied by the schema. It adds no meaningful detail beyond the structured parameter information.
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 uses the specific verb 'list' and names the resource 'articles for a site', with an optional filter by status, which clearly distinguishes it from related tools like get_article or create_article. The scope is unambiguous and immediately understandable.
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 retrieving multiple articles for a site, but it does not explicitly state when to prefer this over get_article or other listing tools. No exclusions or alternative tool names are provided, so guidance is only implied.
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 of behavioral disclosure. It adds the useful detail that the search is a 'semantic + keyword hybrid', which indicates the underlying mechanism. However, it does not disclose return format, pagination, or potential side effects. Since it is a read-only search, the risk is low, but additional context would improve 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, concise sentence that is front-loaded with the action and resource. Every word adds value, with no redundancy or filler.
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 low complexity of the tool (2 simple parameters, no output schema, no nested objects), the description provides adequate context. It states the core function and method, though it could mention what the response contains (e.g., relevant documents, scores). Still, for a simple search tool, it is nearly complete.
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 already covers both parameters (query and limit) with clear descriptions, so schema coverage is 100%. The description adds no extra parameter semantics beyond what the schema provides, so 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 tool's purpose: 'Search the RAG corpus using semantic + keyword hybrid search'. It specifies the verb (Search), the resource (RAG corpus), and the method (hybrid search), which distinguishes it from sibling tools like list_corpus_documents that list documents rather than search semantically.
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 the tool is used for searching the RAG corpus, but provides no explicit guidance on when to use it versus alternatives such as list_corpus_documents or rag_stats. It does not mention exclusions or specific scenarios, leaving usage context implicit.
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?
With no annotations provided, the description must carry the full behavioral burden. 'Get' implies a read-only operation, and the criteria add useful context, but the description does not disclose return format, pagination, or other behavioral traits.
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, front-loaded sentence with no unnecessary words. Every word contributes to defining the tool's purpose and scope.
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 one-parameter tool, the description adequately conveys the input criteria. However, with no output schema, it does not clarify what the returned data structure looks like (e.g., just query strings or metric objects), leaving a completeness gap.
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 covers the single parameter (site_id) with 100% coverage, providing a baseline of 3. The description adds overall purpose but does not elaborate on site_id semantics beyond what the schema already includes.
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 'Get GSC opportunity queries (position 4-20, high impressions)' clearly states a specific verb, resource, and scope. The position and impressions criteria distinguish it from sibling tools like gsc_queries or gsc_growing_queries.
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 criteria (position 4-20, high impressions) provide clear context for when to use this tool. However, there is no explicit mention of alternatives or when not to use it, stopping short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full weight of behavioral disclosure. It does disclose that the tool scrapes and indexes URLs and includes a max limit of 20, which is helpful. However, it omits other behavioral details like whether duplicate URLs are checked, if the operation is synchronous, or what happens on failure, leaving 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 sentence of 11 words, front-loaded with the verb and resource, and embeds critical constraints without redundancy. Every word contributes to understanding the tool's purpose and limitations.
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?
The tool has one required parameter and the description covers the core behavior, but the absence of an output schema and annotations means the agent is left uncertain about the return value, error handling, and post-call state. The 'max 20' limit adds some context, but the description does not fully prepare an agent for edge cases like individual URL failures.
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 already describes the 'urls' parameter as 'URLs to scrape and index' with 100% coverage, so the baseline is 3. The description adds the 'max 20' constraint, which is crucial for an agent to know before making a call, and clarifies the cumulative purpose of the parameter, elevating the score above baseline.
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 'Add URLs to the RAG corpus' with a specific resource, and the parenthetical 'scrapes and indexes them' clarifies the mechanism. This distinguishes it from read-only tools like search_rag and list_corpus_documents, and the explicit mention of 'RAG corpus' differentiates it from sibling populate tools for sites or YouTube.
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 adding URLs to the RAG corpus but provides no explicit guidance on when to use this tool versus alternatives such as add_source or populate_site. It does not state exclusions or conditions that would make another tool more appropriate, so the context is clear but not fully differentiated.
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. It clearly discloses the operation is permanent and that feedback is deleted as well. Missing details like required permissions or effects on related drafts are not covered, but the most critical traits are stated.
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 sentence of eight words, front-loaded with the action and resource. Every word contributes value, with no redundancy.
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?
For a simple delete tool with one required parameter, the description is adequate: it states the destructive nature, permanence, and scope (feedback). While it omits return value or async behavior, such details are less critical for a delete operation.
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 coverage is 100% since the only parameter (brief_id) has a description. The tool description adds no further explanation about the parameter, so the baseline of 3 applies.
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 (permanently delete) and the resource (a brief), and adds the scope 'and its feedback' to distinguish it from sibling delete tools like delete_article or delete_source.
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 use case is implied by the name and description: use this tool when you need to delete a brief. However, there is no explicit mention of when not to use it or alternatives, such as for deleting a draft or article.
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. It discloses two significant side effects: sources are reassigned and briefs are deleted. It also reveals an operational restriction: the last site cannot be deleted. This goes beyond a simple mutation statement, though it could mention permanence or what happens to articles under the site.
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, front-loaded sentence: 'Delete a site'. The parenthetical adds critical context without clutter. Every word earns its place, and the constraint is stated directly. No redundancy or wasted space.
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?
For a simple single-parameter mutation with no output schema, the description covers the essential elements: action, affected resources, and a key constraint. It lacks details about reversibility or response, but given the tool's simplicity and the effective schema, the description is sufficiently complete for most use cases.
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 already provides 100% coverage for the single parameter site_id with a clear description: 'Site ID to delete'. The tool description adds minimal semantic value beyond the schema, mostly the side-effect context. Baseline of 3 is appropriate because the schema does the heavy lifting.
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 'Delete a site' with a specific resource. It distinguishes from sibling delete tools by noting that sources are reassigned (not deleted) and briefs are deleted, which differentiates it from delete_source and delete_brief. The additional constraint 'Cannot delete last site' further clarifies the tool's scope.
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?
Usage guidance is implied rather than explicit. The description says what the tool does but does not state when to use it over alternatives (e.g., delete_source, delete_brief). The 'Cannot delete last site' constraint provides a limited exclusion but no explicit when-to-use or when-not-to-use guidance.
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 must carry full burden for behavioral disclosure. It states 'get' (implying a read operation), but adds no context about authentication requirements, potential errors, rate limits, or what 'limits' and 'sites' represent. The description only lists return facets, which is minimal for full 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, front-loaded sentence that efficiently conveys the tool's purpose and key outputs. Every word earns its place, with no filler or redundancy.
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 simplicity (no parameters, no output schema), the description provides a reasonably complete picture by enumerating the return content (plan, usage, limits, sites). It lacks details on response format or edge cases, but for a basic get-account tool it is sufficient for an agent to select and invoke correctly.
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?
With zero parameters, the schema is trivially complete. The description adds no parameter details but also has no need to. The baseline for 0 params is 4; the description correctly does not invent unnecessary parameter information, and the listed return fields help the agent understand the tool's data.
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 tool's purpose: 'Get your account details: plan, usage, limits, sites' uses a specific verb ('get') and names the resource (account details), enumerating the key information it returns. This distinguishes it from sibling tools like get_profile and list_sites by focusing on account-level attributes.
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: use this tool when you need account-level details (plan, usage, limits, sites). It provides clear context but does not explicitly mention when to use alternative tools (e.g., get_profile for profile info), making it a 4 rather than a 5.
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 of behavioral disclosure. It reveals that the response includes an item count, which is useful, but it does not describe error handling, return format, or any other side effects. For a simple read operation, this is adequate but not comprehensive.
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, front-loaded sentence that wastes no words. It includes the key purpose and a notable detail (item count) without redundant phrasing.
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?
For a simple retrieval tool with one parameter and no output schema, the description adequately conveys the core function and an extra output detail. It lacks information about behavior when the ID is not found, but this is a minor gap for a basic getter.
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%, and the parameter source_id is self-explanatory. The description adds no additional semantic detail beyond the schema, so it meets the baseline for parameter clarity without enhancing it.
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 ('Get a single source by ID') and the resource, distinguishing it from list_sources, add_source, and other sibling tools. The additional detail 'including item count' adds specificity without ambiguity.
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 implicitly defines when to use the tool: when you need a specific source by its ID. It does not mention alternatives or exclusions, but the context is clear given the sibling tools. A more explicit comparison (e.g., 'for listing all sources, use list_sources') would earn a 5.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool returns sites with source and brief counts, but does not explicitly state it is read-only, discuss pagination, or note any authentication requirements. For a simple list operation, this level is adequate but shallow.
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 concise sentence of nine words, front-loaded with the action and resource, and includes a brief detail about the return content. Every word adds value with no redundancy.
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 low complexity (no parameters, no output schema), the description adequately covers the essential information: it lists sites and mentions the counts included. It could be more explicit about the response structure, but for a simple listing tool, the description is effectively complete.
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 zero parameters, so the baseline for this dimension is 4. The description does not need to explain any inputs, and the schema coverage is trivially 100%. No additional parameter semantics are needed.
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 uses a specific verb (List) and resource (sites) with clear scope ('all your sites') and adds what is included ('source and brief counts'). This distinguishes it from sibling list tools like list_sources and list_briefs, which target 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the description: use this when you need to list sites. However, it does not explicitly state when not to use it or mention alternatives, such as using list_sources for source details or get_site for a single site. The guidance is clear for a listing tool but lacks formal exclusions.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the 'cannot remove primary' constraint, which is valuable safety information, and 'Remove' implies a destructive action. Yet it does not mention reversibility, required permissions, or failure behavior, leaving some ambiguity for a deletion 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, front-loaded sentence that immediately conveys the action and the main constraint. It is concise with no redundant words, earning a perfect score for structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity—one required parameter, no output schema, no nested objects—the description covers all essential information. It states the action, the target, and a critical constraint, making it complete for effective 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?
The schema description covers the single parameter email_id at 100% ('Email record ID'), so the baseline is 3. The description adds 'delivery email recipient' context, which clarifies the entity type but does not add syntax, format, or additional semantic detail beyond what the schema already provides.
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 uses the specific verb 'Remove' and the resource 'delivery email recipient', which clearly states the tool's function. It also distinguishes itself from sibling tools like add_account_email and list_account_emails by implying a deletion operation, and the 'cannot remove primary' constraint adds specificity.
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 clearly implies when to use this tool (to delete a delivery email recipient) and provides a key exclusion (cannot remove primary). However, it does not explicitly mention alternatives such as add_account_email or provide contextual guidance beyond the primary constraint, which would make it more complete.
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 of behavioral disclosure. It adds the plan constraint on allowed frequencies, which is valuable, but it does not describe the mutation effects (e.g., whether the schedule is replaced, validation behavior, or consequences of an invalid plan/frequency combination). For a simple update tool, this is adequate but sparse.
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 sentences front-loaded with the core action, followed by the critical plan constraint. Every word adds value—there is no redundant or vague phrasing.
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?
The tool is simple with only 3 well-documented parameters and no output schema. The description covers the essential plan limitation that prevents invocation errors. It lacks detail on update semantics (e.g., partial vs full replacement), but the schema and tool name provide sufficient context. Overall, this is a reasonably complete description for its complexity.
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 already documents all parameters with descriptions (100% coverage), but the description adds crucial plan-based meaning to the delivery_frequency enum, mapping which values are allowed on free vs paid plans. This goes beyond the bare enum list and helps the agent select valid parameter values.
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 ('Update') and the resource ('delivery schedule'). The tool name specifies 'site', and it is distinct from sibling tools like list_deliveries (which lists deliveries) and update_site (which updates site settings). This unambiguously identifies the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides plan-specific usage guidance ('Free plan: weekly only. Paid: daily/weekday/weekly_monday/weekly_friday.'), which tells the agent which delivery_frequency values are valid depending on the account plan. It doesn't explicitly name alternatives, but the unique role of updating a schedule is clear among the sibling tools, and the plan constraint is essential context for correct invocation.
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:

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

Score Badge

Copy to your README.md:

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

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/houtini-ai/contentmarketingideas-mcp'

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