Apollo.io MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have clearly distinct purposes targeting different resources (e.g., contacts, sequences, organizations) and actions (e.g., create, get, search, analyze). However, some overlap exists between 'analyze_list' and 'get_list_contacts' (both involve list data retrieval), and 'enrich_person' and 'find_email' (both relate to person data enrichment), which could cause minor confusion.
Naming Consistency4/5
Tool names follow a consistent verb_noun pattern throughout (e.g., 'create_contact', 'search_people', 'analyze_sequence'), with clear and readable conventions. There are minor deviations like 'get_lists' (plural) versus 'get_sequence' (singular), but overall, the naming is highly predictable and well-structured.
Tool Count4/5
With 19 tools, the count is slightly high but reasonable for a comprehensive sales/CRM platform like Apollo.io, covering contacts, sequences, organizations, and analytics. It avoids being overwhelming (e.g., not exceeding 25) and provides broad functionality without obvious bloat, though it could be streamlined slightly.
Completeness5/5
The toolset offers complete CRUD/lifecycle coverage for the domain: create, get, update, and delete (implied via removal) for contacts and sequences, plus enrichment, search, and analytics tools. There are no obvious gaps; agents can perform end-to-end workflows from prospecting to engagement analysis without dead ends.
Average 3/5 across 19 of 19 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Add contacts') but fails to describe what this entails—e.g., whether it triggers emails, changes contact statuses, requires specific permissions, or has side effects like rate limits. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Add contacts to a sequence') and briefly specifies inputs. There is no wasted text, making it appropriately concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with 4 parameters) and lack of annotations or output schema, the description is incomplete. It doesn't explain the behavioral impact, return values, error conditions, or how it interacts with siblings like 'remove_from_sequence', leaving significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'sequence ID and contact email addresses or contact IDs', which aligns with the schema parameters. Since schema description coverage is 100%, the schema already documents all parameters well, so the description adds minimal value beyond restating them. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add contacts to a sequence') and specifies the target resource ('sequence'), which distinguishes it from siblings like 'create_contact' or 'update_contact'. However, it doesn't explicitly differentiate from 'remove_from_sequence' beyond the verb difference, missing a direct sibling comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'create_contact' for new contacts or 'update_contact' for modifications. It mentions required inputs but offers no context about prerequisites, timing, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'detailed metrics' but doesn't specify whether this is a read-only operation, requires permissions, has rate limits, or what the output format entails. For a tool with no annotations, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that lists key metrics upfront, making it front-loaded and easy to parse. It avoids unnecessary words, though it could be slightly more structured by separating core purpose from metric details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one parameter with full schema coverage and no output schema, the description adequately covers the purpose and metrics but lacks behavioral context (e.g., permissions, output format) and usage guidelines. It's minimally viable for a simple read operation but incomplete for informed tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'id' documented as 'Sequence ID to analyze'. The description doesn't add any parameter details beyond what the schema provides, such as format or validation rules, so it meets the baseline for high schema coverage without extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes sequence performance with specific metrics (open rates, reply rates, bounce rates, etc.), providing a specific verb ('analyze') and resource ('sequence'). It distinguishes from siblings like 'get_sequence' (which likely retrieves metadata) by focusing on performance analytics, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. While it implies usage for performance analysis, it doesn't specify prerequisites (e.g., needing a sequence ID), exclusions, or direct comparisons to siblings like 'analyze_list' or 'get_sequence', leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it creates an account with company details. It doesn't disclose behavioral traits like required permissions, whether the operation is idempotent, rate limits, or what happens on failure. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., account ID, success status) or address potential side effects, leaving significant gaps for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 4 parameters (name, domain, phone_number, website_url). The description adds no parameter-specific details beyond implying 'company details' map to these fields, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create') and resource ('new account/organization in Apollo'), specifying it's for company details. It distinguishes from siblings like 'create_contact' (for contacts) and 'enrich_organization' (for updating existing ones), but doesn't explicitly contrast with 'search_organizations' or 'get_account'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'enrich_organization' (for existing accounts) or 'search_organizations' (for finding accounts). The description implies usage for new accounts only, but lacks explicit exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a contact but doesn't mention permissions required, whether the operation is idempotent, error handling, or what the response looks like (e.g., success/failure indicators). For a mutation tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose ('Create a new contact in Apollo') and includes relevant examples. There's no wasted text, though it could be slightly more structured by explicitly mentioning key parameters or outcomes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., side effects, error cases), usage context, and what to expect upon success or failure, making it inadequate for safe and effective tool invocation by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description adds minimal value by listing examples like 'name, email, title, company, etc.', which loosely maps to parameters but doesn't provide additional syntax, constraints, or meaning beyond what's in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new contact') and resource ('in Apollo'), with examples of details like name, email, title, company. It distinguishes from siblings like 'update_contact' by specifying creation rather than modification, though it doesn't explicitly contrast with all alternatives like 'enrich_person'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'enrich_person' or 'update_contact' is provided. The description implies usage for creating new contacts but lacks explicit context, prerequisites, or exclusions, leaving the agent to infer based on the verb 'Create' alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It implies a read-only enrichment operation but doesn't disclose behavioral traits: whether it's idempotent, requires authentication, has rate limits, returns structured or unstructured data, or handles errors. For a tool with no annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) and front-loaded with the core purpose. The first sentence efficiently lists enrichment targets, and the second clarifies the required parameter. No wasted words, though it could be slightly more structured (e.g., separating usage notes).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'enrich' entails operationally (e.g., fetches external data, updates internal records), the return format, or error handling. For a tool that likely queries external APIs or databases, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with one parameter ('domain') fully documented in the schema. The description adds minimal value beyond the schema by specifying 'Provide domain name' and giving an example ('apollo.io'), but doesn't explain format constraints (e.g., must be a valid domain) or edge cases. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Enrich an organization's data with detailed company information' and lists specific data types (employee count, revenue, technologies, funding). It distinguishes from siblings like 'search_organizations' (which likely finds organizations) and 'enrich_person' (which targets individuals). However, it doesn't explicitly contrast with 'get_account' or 'create_account', leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a domain), exclusions (e.g., not for personal data), or compare to siblings like 'search_organizations' (which might retrieve basic info) or 'get_account' (which might fetch existing account data). The agent must infer usage from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'find and verify,' implying a read-only operation, but does not detail aspects like rate limits, authentication needs, data sources, accuracy, or what 'verify' entails (e.g., validation methods). For a tool with no annotations, this leaves significant gaps in understanding its behavior and 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 concise and front-loaded, consisting of two clear sentences: one stating the purpose and another specifying required inputs. Every sentence earns its place by providing essential information without redundancy or fluff, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of email verification and the lack of annotations and output schema, the description is incomplete. It does not cover behavioral traits, return values, error handling, or usage context relative to siblings. For a tool with no structured data beyond the input schema, more detail is needed to fully understand its operation and limitations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal value beyond the input schema, which has 100% coverage. It implies that parameters are used to identify a person ('Provide name and company domain or LinkedIn URL'), but does not explain semantics like format requirements, interdependencies (e.g., if both domain and LinkedIn URL are needed), or default behaviors. With high schema coverage, the baseline score of 3 is appropriate, as the description does not significantly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Find and verify email addresses for a person.' It specifies the verb ('find and verify'), resource ('email addresses'), and target ('for a person'). However, it does not explicitly distinguish this tool from sibling tools like 'search_people' or 'enrich_person,' which might also involve email-related functionality, leaving some ambiguity about uniqueness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions required inputs ('Provide name and company domain or LinkedIn URL') but does not specify scenarios, prerequisites, or exclusions relative to sibling tools such as 'search_people' or 'enrich_person,' which could overlap in purpose. This lack of context makes it unclear when this tool is the optimal choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states it 'gets' information, implying a read-only operation, but doesn't disclose behavioral traits such as authentication requirements, rate limits, error handling, or what 'detailed information' includes. This leaves significant gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose without unnecessary words. It directly communicates the tool's function and parameters, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of account/organization data, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'detailed information' entails, potential response formats, or error cases. For a read operation with rich data likely returned, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with clear descriptions for 'id' and 'domain'. The description adds minimal value by mentioning these parameters as lookup methods ('by ID or domain'), but doesn't provide additional semantics like format examples or usage constraints beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about an account/organization'), specifying it retrieves data by ID or domain. However, it doesn't differentiate from sibling tools like 'search_organizations' or 'enrich_organization', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_organizations' or 'enrich_organization'. It mentions the lookup methods (ID or domain) but doesn't specify prerequisites, exclusions, or comparative contexts with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'scrape/retrieve' and 'full details', implying a read operation with comprehensive data, but doesn't specify permissions required, rate limits, pagination behavior (beyond schema hints), or potential side effects (e.g., if 'scrape' implies aggressive data fetching). For a tool with no annotation coverage, this leaves significant gaps in understanding its operational traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action and resource. It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., separating scope details). Every part earns its place by clarifying what's retrieved.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 3 parameters, the description is incomplete. It lacks behavioral details (e.g., pagination, rate limits), output format information, and usage context. For a retrieval tool with multiple parameters and no structured output, more guidance is needed to ensure the agent can use it effectively without guesswork.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for 'id' (List ID), 'page' (Page number), and 'per_page' (Results per page). The description adds no parameter-specific information beyond what the schema provides, such as format examples for 'id' or constraints on 'per_page'. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('scrape/retrieve') and resource ('all contacts from a specific list'), specifying the scope ('full details including emails, titles, companies, etc.'). It distinguishes from sibling tools like 'get_lists' (which likely lists contact lists rather than contacts within a list) and 'search_people' (which searches across people rather than retrieving from a specific list). However, it doesn't explicitly differentiate from 'get_person_activity' or 'analyze_list', which might involve contact data but serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a list ID), exclusions (e.g., not for searching across lists), or direct comparisons to siblings like 'search_people' (for broader searches) or 'analyze_list' (for analysis rather than retrieval). Usage is implied by the action and resource but lacks explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying it is read-only, but does not clarify permissions, rate limits, data format, or whether it returns historical or real-time data. For a tool with no annotations, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary details. It is front-loaded and wastes no words, making it easy to parse. However, it could be slightly improved by adding brief usage context without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It does not explain what 'activity history and engagement data' includes, how results are structured, or any limitations. For a tool that retrieves potentially complex data, more context is needed to help an agent use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'id' parameter documented as 'Person/Contact ID'. The description adds minimal value beyond this, as it only reiterates that the tool is for a 'specific person/contact'. Since the schema already covers the parameter semantics adequately, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get activity history and engagement data for a specific person/contact.' It specifies the verb ('Get'), resource ('activity history and engagement data'), and target ('specific person/contact'). However, it does not explicitly distinguish this from sibling tools like 'get_account' or 'get_sequence', which also retrieve data but for different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing a valid person ID, or compare it to sibling tools like 'search_people' for finding people or 'enrich_person' for additional data. Without this context, an agent might struggle to select the right tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't specify whether it requires authentication, has rate limits, returns paginated results, or handles errors. The description adds minimal behavioral context beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It avoids unnecessary words and directly states what the tool does. However, it could be slightly more structured by explicitly mentioning the parameter or output, but it earns its place without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and a simple parameter, the description is incomplete. It doesn't explain what 'detailed information' includes, how to interpret the output, or any behavioral traits like error handling. For a tool that retrieves data, more context on the response format and usage constraints would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'id' parameter documented as 'Sequence ID'. The description doesn't add any meaning beyond this, such as format examples or where to find the ID. With high schema coverage, the baseline score of 3 is appropriate, as the schema handles the parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a specific sequence', including specific attributes like 'steps, stats, and settings'. It distinguishes from siblings like 'list_sequences' (which lists sequences) and 'analyze_sequence' (which might analyze rather than retrieve details), though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing a sequence ID, or differentiate from similar tools like 'analyze_sequence' or 'get_list_contacts'. Usage is implied by the purpose but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but lacks behavioral details. It doesn't disclose pagination behavior (implied by 'page' parameter), rate limits, authentication needs, or what data is returned. The phrase 'List all' suggests comprehensive retrieval but offers no further operational context.
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 brief and front-loaded, with two clear sentences. It efficiently conveys the core purpose without unnecessary elaboration, though it could be more structured with usage hints.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is incomplete. It lacks details on return format, pagination behavior, error handling, or how it fits into the broader context of sibling tools, leaving significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the 'page' parameter. The description adds no parameter-specific information beyond implying pagination through 'List all,' which aligns with the schema but doesn't provide extra semantics like default values or format details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all email sequences in your Apollo account'), with additional context that sequences are 'automated email campaigns.' It distinguishes from siblings like 'get_sequence' (singular) but doesn't explicitly differentiate from other list-related tools like 'get_lists'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, compare to siblings like 'get_sequence' or 'analyze_sequence,' or specify use cases beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is a removal but does not clarify if this is destructive (e.g., permanent deletion or reversible), what permissions are required, or how the operation affects the sequence or contacts. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences that directly state the tool's purpose and parameters without any wasted words. It is front-loaded and efficiently communicates the essential information in a minimal format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for a mutation tool. It does not address behavioral aspects like safety, permissions, or response format, which are critical for proper tool invocation. The high schema coverage helps with parameters but does not compensate for other gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions the parameters ('sequence ID and contact IDs'), but with 100% schema description coverage, the input schema already fully documents these parameters. The description adds no additional meaning, such as format examples or constraints, beyond what the schema provides, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Remove contacts from a sequence') and specifies the resource ('sequence'), making the purpose understandable. However, it does not explicitly differentiate this tool from its sibling 'add_to_sequence' beyond the opposite action, missing a direct comparison that would enhance clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'add_to_sequence' or other contact management tools. It lacks context about prerequisites, scenarios for removal, or any exclusions, leaving usage entirely implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the action ('search') and goal, but lacks critical behavioral details: it doesn't specify if results are paginated (implied by 'page' parameter but not stated), rate limits, authentication needs, or what the output looks like (no output schema). This is inadequate for a search tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Search for job postings') and adds value with the goal context. There is no wasted wording or redundancy, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (search functionality with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error conditions, or usage constraints. The goal context ('find buying signals') is useful but insufficient to compensate for missing behavioral and output details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all three parameters (q_keywords, organization_ids, page). The description adds no parameter-specific information beyond what's in the schema. According to rules, baseline is 3 when schema coverage is high (>80%) and no param info is added in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for job postings' (verb+resource). It adds context about the goal ('identify companies that are hiring and find buying signals'), which is helpful. However, it doesn't explicitly differentiate from sibling tools like 'search_organizations' or 'search_people', which prevents a score of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions the goal ('find buying signals') but doesn't specify scenarios, prerequisites, or exclusions. For example, it doesn't clarify if this is for initial prospecting versus deep analysis, or how it differs from other search tools in the server.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Update' implies a mutation, it doesn't specify required permissions, whether changes are reversible, rate limits, or what happens to fields not mentioned. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a straightforward update operation and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address error conditions, response format, or behavioral constraints that would help an agent use it correctly. The high schema coverage helps with parameters, but other contextual gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description doesn't add any parameter-specific context beyond what's in the schema (e.g., format constraints, validation rules), so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and resource ('existing contact's information in Apollo'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'create_contact' by specifying it's for existing contacts, though it doesn't explicitly differentiate from other potential update operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a contact ID), when not to use it, or how it differs from similar tools like 'create_contact' beyond the obvious 'existing' versus 'new' distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the analysis output but doesn't cover critical behavioral traits: whether this is a read-only operation, if it requires specific permissions, potential rate limits, data freshness, or error handling. For an analysis tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently lists all analysis components without unnecessary words. It's front-loaded with the core action ('Analyze a contact list') and details the breakdown metrics in a clear, comma-separated list. Every part of the sentence contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (analysis with multiple metrics), no annotations, and no output schema, the description is partially complete. It specifies what analysis is performed but lacks behavioral context (e.g., read-only status, permissions) and output details (e.g., format of results). For a tool with these gaps, it's adequate as a minimum viable description but could be more comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'id' documented as 'List ID to analyze'. The description doesn't add any parameter-specific details beyond what the schema provides (e.g., format of the ID, where to find it, or examples). With high schema coverage, the baseline score is 3, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: analyzing a contact list with specific breakdown metrics (total contacts, job titles distribution, seniority levels, etc.). It uses the verb 'analyze' with the resource 'contact list' and details what analysis is performed. However, it doesn't explicitly distinguish this from sibling tools like 'get_list_contacts' or 'get_lists', which might also retrieve list information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid list ID), compare it to siblings like 'get_list_contacts' (which might retrieve raw contacts without analysis) or 'get_lists' (which might list available lists), or specify scenarios where analysis is preferred over simple retrieval. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions what data gets enriched, it doesn't describe behavioral traits such as whether this is a read-only or mutation operation, rate limits, authentication requirements, or what happens if multiple input parameters are provided. For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.
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 appropriately sized with two sentences: the first states the purpose and enrichment scope, and the second specifies input requirements. It's front-loaded with the core functionality, and both sentences earn their place by adding value. Minor deduction because it could be slightly more structured (e.g., bullet points for input options).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (enriching person data with multiple input options), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the enriched output looks like, error conditions, or behavioral constraints like rate limits or data sources. For a tool with no structured safety or output information, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description adds marginal value by grouping parameters into logical input combinations ('email, name+domain, or LinkedIn URL'), but it doesn't provide additional semantics beyond what's in the schema, such as explaining interactions between parameters or the purpose of 'reveal_personal_emails' in context. Baseline 3 is appropriate when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Enrich a person's data with email, phone, social profiles, employment info, and more.' It specifies the verb ('enrich') and resource ('person's data') with concrete examples of enrichment types. However, it doesn't explicitly distinguish this tool from sibling tools like 'search_people' or 'get_person_activity', which prevents a perfect score.
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 provides some usage guidance by stating 'Provide either email, name+domain, or LinkedIn URL,' which indicates acceptable input combinations. However, it doesn't explicitly state when to use this tool versus alternatives like 'search_people' or 'find_email', nor does it mention any prerequisites or exclusions. The guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves 'all contact lists' but does not mention pagination behavior (despite a 'page' parameter in the schema), rate limits, authentication needs, or what happens if no lists exist. For a read operation with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, consisting of two clear sentences: the first states the core purpose, and the second provides helpful context about what lists are. There is no wasted text, and every sentence earns its place by adding value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavioral aspects like pagination or error handling. Without annotations or an output schema, more context would improve completeness, but it meets the basic threshold for a simple read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'page' parameter documented as 'Page number.' The description does not add any meaning beyond this, such as explaining pagination defaults or constraints. With high schema coverage, the baseline score is 3, as the schema handles parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get all contact lists in your Apollo account.' It specifies the verb ('Get') and resource ('contact lists'), and adds clarifying context that 'Lists are collections of saved contacts.' However, it does not explicitly differentiate from sibling tools like 'get_list_contacts' or 'analyze_list,' which reduces it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'get_list_contacts' (which might retrieve contacts within a specific list) or 'analyze_list' (which might analyze list data), nor does it specify prerequisites or exclusions. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'advanced filters' and gives examples of criteria, but doesn't disclose key behavioral traits like pagination behavior (implied by page/per_page params), rate limits, authentication needs, or what the response looks like (no output schema). This is inadequate for a search tool with 9 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by usage context. It's efficient with minimal waste, though it could be slightly more structured by explicitly separating purpose from guidelines.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 9 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain return values, error conditions, or important behavioral aspects like how filters combine (AND/OR). The schema handles parameters well, but the description lacks crucial operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description adds marginal value by listing example criteria (job title, company, location, etc.) that map to some parameters, but doesn't provide additional syntax or format details beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches for people/contacts in Apollo's database with advanced filters, specifying the resource (people/contacts) and action (search). It distinguishes from siblings like 'enrich_person' or 'get_person_activity' by focusing on search functionality, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for finding prospects, leads, or specific individuals based on criteria, providing some context. However, it doesn't explicitly state when to use this vs. alternatives like 'search_organizations' or 'enrich_person', nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions the tool is for searching and filtering, it lacks critical behavioral details such as whether this is a read-only operation, what permissions are required, rate limits, pagination behavior beyond the schema's default values, or what the response format looks like. For a search tool with 8 parameters and no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the purpose and key capabilities, and the second provides usage context. Every sentence earns its place with no wasted words, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the purpose and high-level usage well, but lacks behavioral transparency details and doesn't compensate for the missing output schema. For a search tool with rich filtering options, more context on result format or limitations would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds marginal value by listing example filter categories ('industry, size, location, revenue, technology, and more'), but doesn't provide additional syntax, format details, or usage examples beyond what the schema provides. The baseline of 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Search for companies/organizations') and resource ('Apollo's database'), with explicit mention of filtering capabilities. It distinguishes this tool from sibling tools like 'search_people' and 'search_job_postings' by specifying its focus on organizations rather than individuals or job postings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Great for building targeted account lists'), which implicitly suggests it's for prospecting or lead generation. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, such as when to use 'enrich_organization' instead.
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:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/masridigital/apollo.io-mcp'

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