mcp-gtm-suite

Server Quality Checklist

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

Latest release: v1.1.0
Disambiguation3/5
There is overlap between aggregate_gtm_signals and detect_gtm_tech_stack/scan_gtm_hiring_signals, as the aggregate combines them. Additionally, scan_gtm_hiring_signals and scan_job_board_keywords both scan job boards, though one is GTM-specific and the other category-agnostic. Descriptions help differentiate but some ambiguity remains.
Naming Consistency5/5
All six tools follow a consistent verb_noun pattern in snake_case (e.g., aggregate_gtm_signals, resolve_linkedin_url). The naming is predictable and uniform across the set.
Tool Count4/5
With 6 tools, the count is appropriate for a focused read-only GTM signals suite. It covers the core tasks without being excessive, though one or two more could be justified.
Completeness4/5
The suite covers key GTM signal areas: tech stack detection, hiring signals, job board scanning, LinkedIn resolution, and ICP scoring. The aggregate tool offers a combined view. Minor gaps exist (e.g., company news), but the core workflow is well-supported.
Average 4.3/5 across 6 of 6 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 16 commits in the last 12 weeks
- Last stable release on August 9, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
View related servers

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds value by explaining the data extraction method (schema.org JSON-LD and HTML meta tags) and output structure (source_signals array, data_completeness score), which go beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively concise, with the main purpose front-loaded. It includes necessary details about output format and batch processing without excessive length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no output schema, and sibling tools, the description covers input, output structure, extraction method, batching, caching, credit consumption, and token requirement. It is complete for the agent to understand usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description does not add much for most params, but it does clarify the default cache duration (7 days) for skipCache. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'enrich' and the resource 'company domain' and lists the specific firmographics fields (employee band, industry, HQ, etc.). However, it does not explicitly distinguish from siblings like 'resolve_company_identity' or 'get_company_changes', though the output fields are unique.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions the tool is read-only and requires an APIFY_TOKEN and consumes credits, but provides no guidance on when to use this vs. siblings or what prerequisites (beyond token) are needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint. The description adds that it consumes Apify credits and requires a token, which is useful but not extensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose, then details on what it does and constraints. Efficient and no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers main functionality but lacks details about the output structure (e.g., fields in the Clay-ready JSON row). No output schema, so description should provide more context on return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so description adds minimal meaning beyond the schema. The description mentions optional summary but does not elaborate on parameters beyond schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool aggregates GTM signals into one composite score, mentioning hiring and tech-stack detection. Distinguishes from sibling tools that perform individual scans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Indicates it runs multiple detections in one call and is read-only, but does not explicitly state when to use versus siblings or provide exclusions. The context is clear enough for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds valuable behavioral details: discovery methods (homepage links, web search, pattern guessing, validation), follower count limitations (X URL-only, Instagram/Facebook best-effort), credit consumption, and read-only nature. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences with no fluff. The main action is front-loaded, and every sentence adds value. Structure is clear and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description explains return format (flat Clay-ready JSON with URLs and follower counts) and covers key limitations and requirements. It provides sufficient completeness for an agent to assess the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters well. The description adds context about platform-specific limitations and default behavior but does not significantly enhance parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool maps a company's social media presence across specified platforms, returning profile URLs and follower counts. It distinguishes from siblings like 'resolve_linkedin_url' by covering multiple platforms and providing a broader scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use (need social presence data) and prerequisites (company_domain or company_name, APIFY_TOKEN, credits). However, it does not explicitly state when not to use or compare to alternative tools, missing some guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds that it consumes Apify credits per call and requires a token, which goes beyond annotations. No contradictions, but could mention idempotency explicitly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, no unnecessary words, and front-loads the core action. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters and no output schema, the description covers the core functionality, read-only nature, authentication (APIFY_TOKEN), resource consumption (credits), and output format (flat Clay-ready JSON row). It is mostly complete but could mention that the output is a list of scraped job postings with fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are well-documented in the schema. The description does not add extra meaning beyond what the schema provides, hence baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'scan', the resource 'company career pages', and the specific purpose 'detect GTM hiring activity'. It also lists the ATS platforms (Greenhouse, Lever, Ashby) and output format, distinguishing it from sibling tools like aggregate_gtm_signals or detect_gtm_tech_stack.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions it is read-only and requires an APIFY_TOKEN, but does not provide explicit guidance on when to use this tool versus alternatives like aggregate_gtm_signals or when not to use it. The guidelines are implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and destructiveHint=false. The description adds that it is read-only, requires APIFY_TOKEN, consumes credits, and returns only changes as typed events in Clay-ready JSON. No contradiction. Additional context like rate limits or error handling is not provided, but annotations already cover safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and contains no unnecessary words. It efficiently conveys action, scope, return type, and requirements.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a monitoring tool with no output schema, the description covers the return format (typed change events, Clay-ready JSON), the scope of changes (hiring, tech stack, etc.), and usage requirements (token, credits). Minor gaps like pagination or depth of changes could be added, but overall it is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters are fully described in the input schema (100% coverage). The description adds no extra information beyond what the schema provides, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it monitors a company domain for changes across hiring, tech stack, funding, firmographics, and social. It distinguishes from sibling tools like aggregate_gtm_signals or enrich_company_firmographics by emphasizing monitoring over time rather than one-time enrichment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies periodic use ('since the last run') and mentions requirements (APIFY_TOKEN, credits). It does not explicitly state when not to use it, but the context of monitoring vs. one-time detection is clear from sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and idempotentHint=true. The description adds value by specifying that the output is a flat Clay-ready JSON row and that it consumes Apify credits per call. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose, and each sentence adds necessary information without redundancy. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description enumerates the key outputs (confidence score, firmographics, social links) and describes the format (flat Clay-ready JSON row). It also notes prerequisites and cost, covering all relevant context for a parameter-light tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description paraphrases the schema by restating the at-least-one requirement. It adds a minor example for company_domain (e.g., stripe.com), but does not significantly enhance understanding beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('resolve') and clearly identifies the resource (company domain/name to LinkedIn URL) and output (confidence score, firmographics, social links as flat JSON row). It distinguishes from sibling tools which focus on aggregation, tech stack, or hiring signals.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the requirement to provide at least one of company_domain or company_name, and notes that it is read-only, requires an APIFY_TOKEN, and consumes Apify credits. This provides clear context for when to use the tool, though it does not directly compare with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint, idempotentHint), description adds that it is read-only and consumes Apify credits, which is useful operational context. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and supported platforms, then output format and constraints. No wasted words, highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema, description sufficiently describes return format ('flat, Clay-ready JSON row' with role counts and titles). All 6 parameters are fully described in schema, and context signals indicate high schema coverage. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. Description summarizes the purpose of parameters ('chosen categories') but does not add significant meaning beyond what the schema already provides for each parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States specific verb 'scan' and resource 'job board', lists supported ATS platforms (Greenhouse, Lever, Ashby, Workday, Rippling), and describes output as 'matched role counts and titles per category as a flat, Clay-ready JSON row'. Clearly distinguishes from sibling tools like scan_gtm_hiring_signals.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states read-only nature and prerequisites: 'requires an APIFY_TOKEN and consumes Apify credits per call'. Missing explicit when-not-to-use or comparison with siblings, but context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readonly, destructive false, idempotent, and open world. The description adds important behavioral context beyond annotations, including that it requires APIFY_TOKEN, consumes Apify credits per call, and that icp_description requires an llm_api_key. This provides a clearer picture of the tool's operational constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences that front-load the core purpose and output. Every sentence provides essential information without fluff, making it easy for an agent to quickly understand the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of 9 parameters and no output schema, the description adequately covers key aspects: output format, ICP definition methods, auth requirements, and credit consumption. It does not detail per-signal breakdown structure or behavior when multiple input methods are used, but it is sufficiently complete for typical usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with all parameters described. The description adds value by explaining that parameters like template, scoring_config, and icp_description are alternative ways to define the ICP, and that icp_description requires llm_api_key. This clarifies parameter dependencies and usage patterns beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scores a company against an ICP with weighted signals and specifies the exact output format including icp_score, icp_tier, and per-signal breakdown. It distinguishes itself from sibling tools like aggregate_gtm_signals by focusing specifically on ICP scoring.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains how to define the ICP using template, scoring_config, or plain-English description, and mentions prerequisites like APIFY_TOKEN and credit consumption. However, it does not explicitly state when not to use this tool or suggest alternatives, so it is slightly lacking in exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds valuable context: the need for an APIFY_TOKEN, credit consumption, and the output structure. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, followed by output format and usage constraints. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 parameters, simple output), the description provides all necessary context: what it does, input requirements, output format, and side effects (credit consumption). No output schema exists, but the description adequately specifies the return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds further context: for 'crawl_additional_pages', it explains the behavior (crawl up to 2 extra pages) and default value (true). For 'domain', it specifies the format (bare domain, e.g., stripe.com). This meaningfully supplements the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Detect' and the resource 'GTM tools from a company's public website', and specifies the output format (flat, Clay-ready JSON row with boolean flags). This distinguishes it from sibling tools like 'aggregate_gtm_signals'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is read-only, requires an APIFY_TOKEN, and consumes credits. It implies when to use (to detect GTM stack from a website). However, it does not explicitly state when not to use or provide alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds significant behavioral context: cross-checking inputs, resolving missing ones, flagging conflicts, returning confidence scores and match method, and mentioning Apify credit consumption. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three efficient sentences: first defines core function and output, second explains behavioral details, third covers input requirements and side effects. No unnecessary words, front-loaded with most important information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description fully explains what the tool returns (canonical identity with confidence scores and match method), how it handles conflicts, and prerequisites (APIFY_TOKEN, credit consumption). Complete for a resolution tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all parameters. The description adds value by explaining the role of domain as 'strongest canonical key' and the purpose of skipCache. Overall parameter context is good but not groundbreaking beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'resolve' and the resource 'company identity', specifying it handles any combination of name, domain, or LinkedIn URL. It distinguishes from sibling tools like resolve_linkedin_url by emphasizing it resolves multiple inputs and cross-checks them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance: provide at least one of the three inputs, mentions cross-checking and conflict flagging. Implies when to use (partial identity data) but doesn't explicitly list alternative tools for single-input resolution. Still clear and helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds valuable behavioral details: data sources (Google News, PR wires), deduplication, output format (flat Clay-ready JSON), and prerequisites (APIFY_TOKEN, credits). No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, each valuable: first sentence states purpose, second describes output, third lists constraints. No superfluous content, front-loaded with key info.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, no output schema) and rich annotations, the description covers all needed aspects: input, output, behavior, prerequisites, and cost. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters have schema descriptions (100% coverage). The description further clarifies the 'company_name' parameter with a concrete example (Deel for deel.com), adding meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scans Google News and PR wires for specific signal types (funding rounds, executive moves, etc.) at any company domain. It distinctly differentiates from siblings like 'scan_gtm_hiring_signals' by focusing on funding and press signals.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for usage: read-only operation, required APIFY_TOKEN, and credit consumption. While it doesn't explicitly say when not to use it, the context and sibling list imply appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

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

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

Card Badge

Copy to your README.md:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/mambalabsdev/mcp-gtm-suite'

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