Lead Friendly product info
Server Details
Lead Friendly pricing, industries and capabilities for AI agents, plus demo and lead hand-off
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: demo booking, capability checking, lead submission, pricing lookup, and industry listing. There is no meaningful overlap that would cause an agent to select the wrong tool.
All tool names follow a consistent verb_noun pattern in snake_case: book_demo, check_capability, create_lead, get_pricing, list_industries. This makes the tool surface predictable and easy to navigate.
Five tools is well-scoped for a product information and sales handoff server. Each tool serves a distinct and necessary function without redundancy or bloat.
The surface covers the key product-info workflows: pricing, capabilities, industries, demo requests, and lead creation. A minor gap is the lack of a general product overview or feature-list tool, but agents can reasonably work around this via check_capability and list_industries.
Available Tools
5 toolsbook_demoAInspect
Request a Lead Friendly product demo on behalf of a prospect. Routes the request to the sales team and returns the self-serve booking link. Use when a user wants to see/try Lead Friendly.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Prospect full name | |
| Yes | Prospect email | ||
| company | No | Company name (optional) | |
| message | No | Anything the prospect wants the team to know (optional) | |
| industry | No | Industry/vertical (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It explains that the tool routes a request to the sales team and returns a self-serve booking link, which are the key external effects and outcome. It does not mention potential duplication or email side effects, but it is substantially transparent for a simple request tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first states the action and result, the second gives the usage trigger. Every sentence contributes information, and key details are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity tool with five simple parameters and no nested objects, the description covers what it does, what it returns, and when to use it. There is no output schema, but the description names the return value (booking link), so the agent has enough context to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all five parameters. The description adds 'prospect' framing but no new parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Request') and resource ('Lead Friendly product demo') and clarifies it is done on behalf of a prospect. It also names the outcome (booking link), and this is clearly distinct from sibling tools like get_pricing or create_lead.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives an explicit usage condition: 'Use when a user wants to see/try Lead Friendly.' It does not name alternatives or exclusion criteria, but the context is clear enough for an agent to know when this tool applies versus the listed siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_capabilityAInspect
Check whether Lead Friendly can do a specific job (e.g. 'call leads after hours', 'dispatch trucks', 'white-label for my agency'). Pass the job in query.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The capability/job to check, in plain language. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It conveys that the tool is an evaluation-style check, not a mutating operation, which is useful. However, it doesn't state what kind of response to expect or how definitive the answer will be, leaving some ambiguity for the agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences deliver the purpose, examples, and parameter instruction with no wasted words. The action is front-loaded and the usage guidance follows naturally.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one string parameter and no output schema, the description covers what the tool does and how to invoke it. It could mention the expected answer format, but the current description is sufficient for an agent to select and call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents query as the capability/job to check in plain language. The description adds value with concrete examples that clarify the range of acceptable queries and help an agent phrase the parameter correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific, evaluative purpose: checking whether Lead Friendly can handle a particular job. Concrete examples like 'call leads after hours' and 'white-label for my agency' make the tool's function easy to understand and distinguish from sibling tools like book_demo or get_pricing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the intended use case clear: use it when someone wants to know if Lead Friendly can perform a job, and pass that job in the query parameter. It doesn't explicitly name alternatives or say when not to use it, but the context and sibling tool names make the boundary inferable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_leadAInspect
Submit a sales lead to Lead Friendly on behalf of a prospect who is interested. Routes to the sales inbox. Does NOT write into any customer's CRM. Use to hand off an interested prospect.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Prospect full name | |
| Yes | Prospect email | ||
| notes | No | Context about the prospect's need (optional) | |
| phone | No | Prospect phone (optional) | |
| company | No | Company name (optional) | |
| industry | No | Industry/vertical (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It discloses that the lead is routed to the sales inbox and explicitly states a non-destructive boundary: it does NOT write to any customer CRM. It does not cover success responses or idempotency, but the core mutation behavior and safety constraint are transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, no filler; the core action, destination, and boundary are front-loaded, and the usage cue is at the end. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple lead creation with all parameters documented and clear routing. The only missing piece is what the agent should expect in response (no output schema), but for this low-complexity handoff that is a minor gap. Overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already explains all six parameters. The description adds only the general context that this is on behalf of an interested prospect; it does not add detail beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action (submit), target (Lead Friendly sales inbox), and subject (prospect). The 'Does NOT write into any customer's CRM' also separates it from potential CRM-writing tools; siblings like book_demo/get_pricing are clearly unrelated, so an agent can recognize when create_lead is the intended tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Use to hand off an interested prospect' explicitly states the triggering condition, and 'Does NOT write into any customer's CRM' gives a when-not/boundary signal. It stops short of naming alternatives like book_demo for the demo-ready scenario, so it is clear but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pricingAInspect
Get Lead Friendly's current subscription plans and prices (live from the pricing source of truth). Use to answer 'how much does Lead Friendly cost'.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It does add the useful detail that the data is fetched 'live from the pricing source of truth,' indicating it is not cached and reflects current pricing. The verb 'Get' implies a non-mutating read operation, which is adequately transparent for a simple no-parameter tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no filler. The core action and resource are front-loaded, and the usage hint is given in a single clear clause. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless tool with no output schema, the description is fully complete. It states what it does, the source, and the exact use case. Sibling tools are clearly different, and nothing an agent needs to invoke this tool correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is trivially 100% and there is nothing to document. The baseline for 0 parameters is 4, and the description does not need to add parameter semantics. It correctly omits any irrelevant parameter references.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get'), a specific resource ('Lead Friendly's current subscription plans and prices'), and adds the key qualifier that it is 'live from the pricing source of truth.' This clearly distinguishes it from siblings like book_demo or create_lead, which are unrelated actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly tells the agent when to use it: 'Use to answer "how much does Lead Friendly cost."' This is a direct, actionable trigger. It doesn't explicitly state when not to use it, but given the sibling set and the tool's purpose, the guidance is unambiguous and sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_industriesAInspect
List the industry verticals Lead Friendly ships a tailored AI agent template for (e.g. auto dealerships, trucking/dispatch, dental, HVAC). Optional query filters by keyword.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Optional keyword to filter industries (e.g. 'auto', 'medical'). |
TDQS
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 discloses that it lists templates and includes an optional query filter, but doesn't mention pagination, sorting, or the shape of the response. Since it's a read-only list operation, the safety profile is implied but not stated. The description adds the 'tailored AI agent template' context but lacks behavioral details like limits or ordering.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main purpose and examples, then the optional query. Zero fluff. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool is a simple list with one optional param and no output schema, the description is mostly complete. However, it lacks any mention of response format (e.g., array of strings) or whether the query is case-insensitive. For an agent to use it effectively, these are minor gaps but with a single-param tool, this is near adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the single 'query' parameter is already documented in the schema. The description repeats the filter intent without adding new syntax or semantics. Baseline 3 is appropriate when schema covers the parameter fully.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'industry verticals' with concrete examples (auto dealerships, trucking/dispatch, dental, HVAC) that distinguish it from sibling tools like get_pricing or book_demo. The scope is precise: it lists templates Lead Friendly ships for tailored AI agents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies a read-only browsing use case but doesn't explicitly state when to use it versus alternatives. However, the sibling set (book_demo, check_capability, create_lead, get_pricing) is clearly different, and the tool's purpose is self-evident for discovery tasks. No exclusions or alternate routing provided, but context makes it clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
- First observed
book_demo - First observed
check_capability - First observed
create_lead - First observed
get_pricing - First observed
list_industries
Related MCP Connectors
Lets AI agents get leads on the phone: call, send SMS, and schedule callbacks for sales teams.
AI phone calls, SMS and CRM records in one Lead Friendly account, compliance-checked on every send
Public MCP for gethal.ai — autonomous AI sales agent. Pricing, features, book a demo.
AI agents find, message & book SMBs; pay per call in USDC on Base via x402. 14 tools, compliant.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to drive real customer visits to physical stores for $24.99 per verified visitor, with tools for pricing, industry listings, and knowledge base queries.-
- AlicenseAqualityCmaintenanceInject real-time leaked B2B SaaS pricing, historical discounts, and aggressive negotiation playbooks directly into AI agents.13 npm1MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for qualifying and responding to inbound leads in seconds using a multi-agent AI pipeline.1MIT
- AlicenseNot gradedqualityDmaintenanceSales Intelligence · B2B Lead Extraction An MCP (Model Context Protocol) server that gives AI agents structured B2B lead intelligence extracted directly from company websites. Point it at any URL and get back a clean JSON object — company summary, buying signals, inferred needs, and personalised icebreaker lines — ready to drop into your outreach pipeline. Built for agent pipelines. Works with Cl1MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.