Agent-first resource directory for AI agents: protocols, security, RAG, memory, evals, and more.
Each tool targets a distinct action: checking access, fetching corpus (free vs full), pricing, payment, listing, searching, stats, and single resource retrieval. No significant overlap.
All tools follow a consistent verb_noun pattern in snake_case (e.g., check_access, get_corpus, list_resources). Verbs are uniform and descriptive.
With 10 tools, the set is well-scoped for a resource access and management API. Each tool serves a clear purpose without redundancy or excessive number.
The toolset covers core operations: access verification, corpus retrieval (free and premium), pricing, payment info, resource listing, search, and stats. Missing write operations (e.g., purchase), but acceptable for a read-focused server.
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?
With no annotations provided, the description carries the burden of explaining behavior. It adds meaningful context by stating this is from the 'free editorial layer' and describes the returned components. Yet it does not mention authentication requirements, rate limits, side effects, or explicitly state that the operation is read-only (though 'Fetch' implies it).
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 with no fluff; the first sentence identifies the operation and output, the second gives discovery guidance. It is appropriately front-loaded and compact.
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 compensates by enumerating exactly what is returned: pillar metadata, every sub-article with variant URLs, and full Markdown body. The single parameter and its discovery hint are covered. Minor gaps like error handling or explicit read-only wording remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents cluster_id with 100% coverage and an example. The description adds further value by pointing to list_articles as the discovery mechanism for cluster ids, strengthening the semantic understanding of the parameter.
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 clearly names the resource as 'one ChangeGamer guide cluster (topic bundle)'. It also enumerates the returned content (pillar metadata, sub-articles, full Markdown body). However, it does not explicitly distinguish this from sibling tools like get_article or get_corpus, so it falls just 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a useful discovery tip: 'Use list_articles to discover cluster ids', which helps the agent find the required parameter. However, it does not tell the agent when to choose get_cluster over get_article or get_corpus, leaving usage largely implied.
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?
No annotations are provided, so the description must carry the behavioral burden. It is transparent about the runtime merge from the static articles index and frames the output as a lightweight freshness signal. It does not mention cost, caching, or failure modes, but that is less critical for a parameterless stats endpoint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-structured, with the core purpose front-loaded and each element earning its place. The comma-separated enumeration is easily parseable, and the final sentence provides a clear, short takeaway about how to use the 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 there is no output schema and no parameter schema, this description is exceptionally complete: it spells out nearly every returned component and even notes the runtime merge behavior. An agent can confidently predict what this tool will return and why it is useful before invoking 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 and an empty schema, so the baseline is 4. There are no parameters for the description to explain, and the description correctly focuses entirely on the return value rather than inventing parameter semantics.
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 specifies a clear verb ('Return') and a precise resource ('corpus stats') and goes on to enumerate exactly what kinds of statistics are included: total/free/premium counts, category counts, tag count, dates, recent resources, feed URLs, and an editorial block. This is detailed enough to distinguish get_stats from sibling tools like get_corpus or list_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 provides clear context: this tool returns a freshness/size signal to poll before deciding whether to re-ingest. It does not explicitly name alternatives or state when not to use it, but it gives a concrete use case that helps an agent select it correctly.
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?
No annotations are provided, so the description carries the full burden of explaining behavior. It discloses server-side ranking weights, the returned fields (type, slug, title, and .md URL), and the exclusion of body content. It does not, however, discuss errors, rate limits, or empty-result behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loads the core action and scope, and every sentence adds information: ranking logic, result fields, and a follow-up tool recommendation. There is no wasted wording.
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 two simple parameters, complete schema coverage for both, and no output schema, this description provides a full end-to-end picture of what the tool returns and how to proceed. The return shape and the absence of body content are explicitly covered, which is the key guidance agents need to invoke fetch tools next.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description adds meaningful context beyond the schema: it explains how us q's keyword hits are ranked (title heaviest, then tags, but since no enums or output schema exist, the description covers the essential operational details. It explains the response shape, what is not returned, and the next step for fetching full content. A minor gap remains regarding output format and error cases, but those are not critical for invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a precise verb and resource: 'Keyword search across ALL ChangeGamer content (resources and editorial guides)'. This differentiates the general search from the sibling search_resources by emphasizing scope and content type.
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 clearly states the search scope and tells the agent to use get_resource or get_article for the actual content after searching. However, it does not explicitly differentiate from the sibling search_resources, though 'ALL ChangeGamer content' implies a broader scope than a resource-only search.
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. Dates show when Glama detected each change.
get_clustersearchget_articlelist_articlescheck_accessget_full_corpusget_payment_infoget_pricingget_statsget_corpussearch_resourcesget_access_infoget_resourcelist_resourcesClaiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity – fastest for official registry listings. For a namespace such as io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such as io.github.acme/server also needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.
HTTP challenge – works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at /.well-known/glama.json on the same origin as the connector, then choose Check HTTP challenge.
DNS challenge – works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
No comments yet. Be the first to start the discussion!
