Agent-first resource directory for AI agents: protocols, security, RAG, memory, evals, and more.
Scored across 14 tools
Most tools are distinct: get_corpus vs get_full_corpus clearly separate free vs premium, get_resource vs get_article target different content types. However, get_access_info and get_pricing both convey access/pricing details, and search vs search_resources have overlapping purposes though descriptions differentiate scope.
Tool names consistently follow verb_noun pattern: get_* for fetchers, list_* for enumerations, search for queries. The only deviation is check_access, but it uses a clear verb and fits the style. No mixing of conventions.
14 tools is well within the ideal range for a content-access server. Each tool covers a distinct aspect (listing, fetching, searching, stats, access, payment), and none feel redundant or unnecessary.
The surface covers the full lifecycle for a read-only content server: discovery (list, search), retrieval (get for resources, articles, clusters, corpus), access management (check_access), and metadata (stats, pricing, payment). No obvious missing operations for the stated purpose.
Verify an access key and report what it unlocks. Returns valid:true/false; when valid, the tier, when it was created, the premium slugs it unlocks, and that it grants the gated /api/corpus.full.jsonl + get_full_corpus deliverable. Never returns the key, email, or Stripe session. Use this to confirm a freshly-purchased key works before relying on it.
| Name | Required | Description | Default |
|---|---|---|---|
| api_key | Yes | Access key to verify (cg_...) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the return format (valid:true/false and details when valid) and explicitly states what it never returns (key, email, Stripe session), providing good behavioral context beyond the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with two sentences that front-load the main purpose and provide necessary details in a structured manner with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description is complete. It explains return values, what is included when valid, and explicitly states omissions. No additional context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes the single parameter (api_key) with 100% coverage. The tool description adds no additional parameter semantics but mentions output constraints ('Never returns the key'). Baseline 3 is appropriate as schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Verify an access key') and its result ('report what it unlocks'). It uses a specific verb and resource, distinguishing it from siblings like get_access_info which might serve a different purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use the tool: 'Use this to confirm a freshly-purchased key works before relying on it.' It provides a clear use case but does not explicitly state when not to use or mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return current access and pricing information for ChangeGamer resources.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states 'Return' implying read-only, but does not disclose authentication requirements, caching, side-effects, or whether the info is for the current context or global.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It is appropriately sized for a simple retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description is adequate for a basic info retrieval. However, it does not clarify the relationship to siblings like 'get_pricing' and 'check_access', leaving ambiguity about overlap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters and schema coverage is 100%, so no parameter info is needed. However, the description could add context about what the output contains (e.g., keys like 'accessLevel' or 'price') but does not.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Return' and the resource 'current access and pricing information for ChangeGamer resources,' distinguishing it from siblings like 'get_pricing' (likely just pricing) and 'check_access' (likely just access). However, it could be more specific about whether it returns info for the current user or all resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. Sibling tools like 'get_pricing' and 'check_access' exist, but the description does not explain when to prefer 'get_access_info' over them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one ChangeGamer guide (editorial article) by slug as full Markdown with its metadata header. Always free — never part of the paid corpus. Use list_articles to discover slugs.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Article slug (e.g. "rag-in-production") |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description bears the full burden. It provides an important behavioral guarantee (always free, not in paid corpus) and shares the output format (full Markdown with metadata header). Error behavior is missing, but for a read-only fetch this is largely sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with no over-explanation. All three components — purpose, output details, and slug discovery hint — are front-loaded and directly informative, making it fast for the agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description correctly mentions the value format (Markdown + metadata header). With a single required parameter and a clearly captured free and discovery behavior, this is good coverage for an 1-input fetch operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the slug is already well-described with an example in the schema. The description adds extra context beyond the schema by telling the agent that slugs are discoverable via list_articles, which improves accurate parameter selection.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Fetch') and names the resource: a single ChangeGamer guide (editorial article) by slug, returned as full Markdown with a metadata header. It distinguishes the tool from list/get resource siblings by emphasizing the article type and one-item scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly instructs to use list_articles for slug discovery, which sets up a clear 'use get_article once you have a slug' workflow. It does not enumerate all alternative tools or exclusions (e.g., search_resources), but it provides a concrete usage tip within the tool itself.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one ChangeGamer guide cluster (topic bundle) from the free editorial layer: pillar metadata, every sub-article with variant URLs, and the pillar’s full Markdown body. Use list_articles to discover cluster ids.
| Name | Required | Description | Default |
|---|---|---|---|
| cluster_id | Yes | Cluster id, e.g. "rag-in-production" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full burden. It does substantial work: clarifies it returns a structured bundle (pillar metadata, sub-articles with variant URLs, full Markdown body) and specifies the free editorial tier. Minor gaps remain (no error/not-found behavior, no auth requirements spelled out), but the read-only, compositional nature of the call is well conveyed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the what (fetch a cluster bundle), details the return composition in one compact clause, and closes with a practical discovery tip. Every sentence earns its place; no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although there is no output schema, the description enumerates the three main return elements (pillar metadata, sub-articles with variant URLs, full Markdown body), so the agent knows what to expect. The required parameter and its example are covered by schema. Missing aspects are minor for a get-by-id tool: no explicit statement of error behavior for invalid cluster ids or indication of payload size, but the scope is well defined.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a concrete example ("rag-in-production"), and the description adds provenance guidance ('extract from editorial layer,' 'Use listarticles to discover ids'), clarifying what the cluster_id identifies beyond the schema's 'Cluster id.' Since there is a single parameter and the cost of misuse is low, this is strong value above the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (fetch) and resource (ChangeGamer guide cluster/topic bundle) and enumerates the exact payload: pillar metadata, sub-articles with variant URLs, and the full Markdown body. This clearly differentiates it from siblings like get_resource and list_articles because it maps to a distinct 'cluster' concept with a defined composition.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells the agent how to source a valid input ('Use list_articles to discover cluster ids') and scopes the tool to the 'free editorial layer,' which implies when no premium/access checks are needed. It does not explicitly state when NOT to use this tool, but the discovery hint and layer scoping give clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the entire free corpus as one document (every free resource title, description, canonical URL, and full Markdown body) — the same content as /llms-full.txt. Premium resources appear as a stub with a purchase link, not their body. Use this to ingest everything in a single call; the response is large.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the response size is large, that premium content is only a stub, and that it mirrors '/llms-full.txt'. This provides adequate behavioral context for a read-only operation without needing to mention rate limits or authentication.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with essential information: first sentence defines the tool's output in detail, second provides usage guidance. No redundant or filler words. Information is front-loaded and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description fully covers what the agent needs to know: what the return contains (free vs premium), its size, and its similarity to a known URL. It is self-contained and adequate for invoking this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters (0 params, schema coverage 100%). The baseline for zero parameters is 4. The description adds no parameter-specific info, which is acceptable since there are none to elaborate on.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the entire free corpus as one document, detailing exactly what free resources include (title, description, canonical URL, full Markdown body) and how premium resources appear (stub with purchase link). It distinguishes itself by explaining the scope (free vs premium) and references '/llms-full.txt' for clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this to ingest everything in a single call; the response is large,' which guides when to use it for bulk ingestion. It implies alternatives for accessing individual resources or premium content, but does not explicitly name sibling tools like 'get_resource' or 'get_full_corpus'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the ENTIRE corpus including premium resource bodies in one document — the keyed deliverable of the Corpus/Enterprise license. Requires a Corpus- or Enterprise-tier api_key (a Starter key unlocks premium resources but NOT the corpus file); without an entitled key a payment-required/upgrade object is returned. The free, premium-stubbed version is get_corpus.
| Name | Required | Description | Default |
|---|---|---|---|
| api_key | No | Corpus/Enterprise license key (cg_...) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that an unauthorized key returns a payment-required/upgrade object, and that it returns entire corpus in one document. No annotations to contradict; fully self-contained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences each carrying distinct information: purpose, licensing requirement, and alternative. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With only one parameter and no output schema, the description sufficiently covers what the tool returns, when to use, and error behavior. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema already describes api_key; description adds the specific format and license requirement, going beyond schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'Return' and resource 'corpus' with scope 'ENTIRE including premium resource bodies'. Distinguishes from sibling 'get_corpus'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states required license level (Corpus/Enterprise), what Starter key does vs not, and the alternative 'get_corpus' for free version.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the agent payment manifest: every way to pay (HTTP 402 + Bearer key, MCP, Stripe checkout, x402, RSL per-crawl), the exact 402 retry loop, what is always free, and the recommended path per use case. Same data as /api/payment.json.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses the data content (payment methods, retry loop, free items, recommended path) and refers to the API endpoint, but does not explicitly declare it as read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with action and content list. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers key aspects of what is returned, including various payment methods and paths. Lacks explicit format specification, but the reference to /api/payment.json compensates somewhat.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema, so baseline is 4. Description adds no param info, but none needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Return the agent payment manifest' and enumerates specific payment methods and details, distinguishing it from sibling tools like check_access or get_pricing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for when to use this tool (to get payment info), but does not explicitly state when not to use or mention alternatives. However, sibling tool names imply differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the full paid-offer catalog: every tier with price, currency, interval, checkout URL, what it unlocks, deliverables, and license grant — plus the free layer and premium slug list. Same data as /api/pricing.json.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It states the return data and references an API endpoint, indicating a read-only operation. However, it lacks details on authentication requirements, rate limits, or whether the data is cached.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. Front-loads the core purpose and includes a reference for verification. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no input schema and no output schema, the description fully covers the tool's purpose and return value. It provides enough detail for an agent to decide when to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it correctly omits any parameter discussion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns the full paid-offer catalog with specific fields (tier, price, currency, interval, checkout URL, etc.) and mentions the free layer and premium slug list. It distinguishes from sibling tools by specifying its unique data scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: to get the complete pricing catalog. However, it does not explicitly state when not to use it or suggest alternative tools. Given no input parameters, the usage context is straightforward, but a mention of alternatives like get_payment_info could improve it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a ChangeGamer resource by slug. Free resources return full metadata and Markdown body. Premium resources require a valid api_key; without one a payment-required object is returned.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Resource slug (e.g. "getting-started") | |
| api_key | No | Access key for premium resources |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose behavior. It does so by explaining that free resources return full metadata and Markdown body, while premium resources require an api_key or return a payment-required object. This covers key 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences, front-loading the main purpose. While clear, it could be slightly more structured (e.g., separating free and premium cases) but remains effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains return types for free and premium scenarios. It could mention error cases (e.g., invalid slug), but the provided information is sufficient for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters (slug and api_key) are described in the schema with 100% coverage. The description adds semantic value by explaining the role of slug (resource identifier) and api_key (for premium access) in the context of free vs premium resources.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches a ChangeGamer resource by slug, and distinguishes between free and premium resources. This differentiates it from sibling tools like get_corpus or get_stats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description specifies when to use the tool (by slug) and provides context about free vs premium resources. However, it lacks explicit guidance on when not to use it or how to choose among siblings like get_full_corpus.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return corpus stats: total/free/premium counts, per-category counts, tag count, newest/oldest update dates, the 10 most recently updated resources, feed URLs — plus an editorial block (guide count, words, newest publish) merged at runtime from the static articles index. A small freshness/size signal to poll before deciding whether to re-ingest.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the behavioral transparency burden. It does disclose useful behavior beyond the name, such as the editorial block being 'merged at runtime from the static articles index' and the freshness/size signal purpose. However, it does not describe any side effects, auth requirements, or response format. Overall, it gives moderate, but not complete, behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is economically structured: a single dense leading sentence enumerating the content, followed by one short sentence stating the intended use case. There is no fluff, and the most distinctive features are front-loaded in the list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of parameters and output schema, the description is nearly complete for an agent deciding how to invoke it. It specifies both what is included and why it would be used. It could be strengthened by naming the sibling tools it is not, but the provided context is enough to understand the tool's role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline score is 4. The description does not need to add parameter information because the schema already contains no properties. The description goes a step further by clarifying the kind of detailed output the tool produces, which is more than sufficient for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and object, 'Return corpus stats', and then enumerates a detailed breakdown: total/free/premium counts, per-category counts, tag count, dates, recent updates, feed URLs, and an editorial block. This clearly distinguishes the tool from siblings like get_corpus and get_full_corpus because the focus is aggregated statistics, not corpus content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context for when to use this tool: 'A small freshness/size signal to poll before deciding whether to re-ingest.' It clearly communicates the polling use case, though it does not explicitly name alternatives or exclusions. This is solid practical guidance with only minor ambiguity about how it compares to other list/resource tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all ChangeGamer editorial guides (always free, separate from the licensable corpus): cluster-first hub/spoke graph with every article's title, search intent, word count, takeaways count and variant URLs. No body content — fetch bodies with get_article.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description responsibly carries the burden of behavioral disclosure. It explains that the output is a cluster-first hub/spoke graph with a defined list of fields, explicitly notes that body content is absent, and clarifies the resource scope. It leaves out details like auth requirements or pagination, but for a zero-parameter list endpoint this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences accomplish multiple goals: scope, fairness, content taxonomy, field list, and routing to get_article. Nothing is redundant; the most important 'free and separate from corpus' positioning is front-loadaded, and the exclamation body fetch note is at the end.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description covers the essential return values (a structured graph of article metadata), the limitation (no body content), and the clear fallback (get_article). It is also easy for an agent to select this tool against all sibling tools because its scope is explicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so baseline 4 is granted. The description adds no parameter-level information because none is needed; it fully describes what is returned without referencing any inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'List all ChangeGamer editorial guides.' It clearly distinguishes these guides from the 'licensable corpus' and enumerates exactly what fields appear in the results (title, search intent, word count, takeaways count, variant URLs). This makes its role unambiguous and separates it from sibling tools like list_resources or search_resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool (for editorial guides, which are always free) and when not to use it: 'No body content — fetch bodies with get_article.' It names the correct sibling alternative and the condition that triggers it, leaving no ambiguity about routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all ChangeGamer resources with metadata and absolute URLs. Returns slug, title, description, category, tags, updated date, premium flag, and HTML/Markdown/JSON variant URLs. No body content.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool returns metadata and URLs but no body content. This is transparent for a read-only listing tool. However, it does not mention potential pagination, ordering, or rate limits, but for a simple list without parameters, the description is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences. The first sentence states the purpose and what is returned. The second sentence lists the return fields and explicitly states what is not included. Every sentence adds value, and the information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description provides sufficient information: it lists all resources, specifies the returned fields, and clarifies that no body content is returned. It is complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so the baseline is 4. The description adds context about what the tool does but has no need to describe parameters. No additional parameter information is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all ChangeGamer resources with metadata and absolute URLs. It specifies the exact fields returned and distinguishes itself from similar tools by explicitly stating it returns no body content and is a list of all resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for retrieving the full catalog of resources without filtering. While it does not explicitly mention when not to use or name alternatives, the sibling tools (e.g., get_resource, search_resources) provide contrast, and the simplicity of the tool makes its use case clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Keyword search across ALL ChangeGamer content (resources and editorial guides) with server-side ranking: term hits in title weigh most, then tags, then description. Returns ranked rows with type, slug, title and .md URL (no body content). Use get_resource/get_article to fetch winners.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Search query — one or more keywords | |
| limit | No | Max results (default 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and does it well. It discloses server-side ranking with the specific field weights (title, then tags, then description), and clearly states the return payload contains type, slug, title, and .md URL with no body content. This is genuinely useful behavioral detail beyond the input schema and tells the agent what to expect from a call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded. Every sentence adds value: the first states scope and ranking behavior, the second defines the return format and its limitation, and the third routes the follow-up fetching. It is concise without omitting needed details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only keyword search tool, the description is sufficient. It explains the ranking, output fields, the absence of body content, and the next-step tools to get full content. It also has no output schema, so the explicit return-shape description compensates well. Pagination is fully covered by the limit parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers 100% of the parameters, both with solid descriptions, max/min values, and the default limit. The description does not need to add parameter-level detail, so the baseline 3 applies. It offers no extra parameter meaning beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with a specific verb ('search') and a precise resource scope ('ALL ChangeGamer content (resources and editorial guides)'), making the tool's function clear. It also distinguishes from the narrower sibling search_resources by emphasizing the 'ALL' content scope and by naming the follow-up fetch tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: it is a global keyword search over resources and editorial guides, and it directs the agent to use get_resource/get_article for fetching winners. However, it does not explicitly contrast this tool with the sibling search_resources or state when not to use it, so the guidance is implied rather than fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the ChangeGamer corpus by keyword. Ranks resources by relevance across title, description, tags, category, and body, and returns metadata plus HTML/Markdown/JSON URLs (no body content). Use this to find resources before fetching them with get_resource.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results (default 10). | |
| query | Yes | Search keywords, e.g. "retrieval augmented generation" or "mcp auth" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses behavioral traits: it ranks by relevance across multiple fields, returns metadata and URLs, and explicitly states 'no body content.' It does not mention auth needs or rate limits, but for a read-only search tool, these are less critical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place: first defines purpose and behavior, second gives usage advice. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate but lacks detail on the return format. Without an output schema, the agent would benefit from knowing the structure of results (e.g., fields like id, title, score, URLs). The mention of 'metadata plus HTML/Markdown/JSON URLs' is vague.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover both parameters (query and limit). The description adds value by specifying which fields are searched (title, description, tags, category, body) and that results are ranked by relevance, which is not in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches the ChangeGamer corpus by keyword, ranks by relevance across title, description, tags, category, and body, and returns metadata plus URLs but no body. This distinguishes it from siblings like get_resource which fetches full resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this to find resources before fetching them with get_resource,' providing clear context for when to use this tool. However, it does not mention alternatives like list_resources or cases where this tool should not be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
get_clustersearchget_articlelist_articlescheck_accessget_full_corpusget_payment_infoget_pricingget_statsget_corpussearch_resourcesget_access_infoget_resourcelist_resources
Add one secure layer between your agents and this server.