Read-only MCP for a curated directory of young security companies: search, company profiles, listing checks and CC BY 4.0 stats. No key.
Scored across 6 tools
The three lookup-flavored tools (check_if_listed, get_startup, search_startups) partially overlap, since an agent could attempt all of them for what is really a name lookup. The descriptions do a good job of separating them: substring/exact-name matching plus listing guidance vs. exact slug retrieval of all fields vs. filtered directory search. Stats and stats_history are clearly distinguished by the 'never interpolated snapshot' framing.
Every tool follows a snake_case verb_noun pattern (check_if_listed, get_startup, get_stats, get_stats_history, list_categories, search_startups). The get_stats / get_stats_history pair is a clean, predictable naming pair, and no camelCase or vague standalone verbs appear.
Six tools is well-scoped for a read-only directory server: one per resource-plus-action (membership check, single record, search, categories, current stats, historical stats). Nothing feels padded or thin, and each tool covers a distinct need.
Coverage is strong for a public read-only directory: membership check, single-record retrieval, search, category enumeration, and both current and historical aggregates. The only minor gaps are pagination/bulk-listing behavior for search results and no dedicated way to browse all companies without supplying filters, both of which an agent can likely work around.
Check whether a company appears in the directory (name or slug contains the text). When it does not, the result says how a person can get it listed.
| Name | Required | Description | Default |
|---|---|---|---|
| company_name | Yes | Company name or part of it. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds real value beyond them by disclosing the matching semantics - substring match against name or slug - and what the result contains on a miss. Case sensitivity or exact-vs-partial precedence is left unstated.
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, no filler, with the core operation front-loaded and the negative-case behavior trailing as supporting detail. Every clause carries information.
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 one-parameter read-only existence check with no output schema, this covers what an agent needs to call it and interpret a miss. It is slightly thin on the positive result - whether a match returns the listed entry or just a boolean - which matters since there is no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is documented as 'Company name or part of it', which sets the baseline at 3. The description adds meaning the schema omits: the same text is also matched against slugs, not just names. That is a genuine semantic addition, though there is only one parameter to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Check whether a company appears in the directory'. The parenthetical clarifies the matching rule (name or slug contains the text). It stops short of naming how it differs from search_startups, which is the closest overlapping sibling, so it is clear but not fully differentiated.
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?
Usage is only implied - the tool is evidently for a quick existence lookup before listing. The negative-case note ('the result says how a person can get it listed') hints at the workflow, but there is no explicit when-to-use-this vs. search_startups or get_startup guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get one listed company by slug (or exact name): every public field plus its page URL.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Company slug from search results, e.g. aikido-security, or the exact company name. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description still adds useful context by saying the response includes "every public field plus its page URL", which matters since there's no output schema. It omits what happens on a miss (error vs empty), keeping it from a 5.
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?
One tight sentence with the resource first, the key second, and the return shape last. Nothing is padded or repeated.
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 single-parameter read with no output schema, telling the agent the response is the full public record plus page URL is nearly sufficient. Only the not-found behavior and the exact-name matching fallback are unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the slug definition already explains the format and example, so the schema carries the load. The description's "(or exact name)" restates what the schema already documents, adding no new syntax or matching-rule detail. 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?
States a concrete verb and resource ("Get one listed company") and the lookup key (slug or exact name), plus what comes back. It implicitly distinguishes itself from list/grid siblings like search_startups by emphasizing a single record, though it never names an alternative.
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 "from search results" hint in the schema and "slug" in the description imply the intended flow (search first, then fetch by slug), but the description itself gives no explicit when-to-use or when-not guidance and doesn't reference search_startups or check_if_listed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The list in numbers: five aggregates of the listed companies (category, funding stage, headquarters, founded year, minimum disclosed funding), each with n, coverage, caveat, method, as-of date, CSV and chart URL. CC BY 4.0 with attribution.
| Name | Required | Description | Default |
|---|---|---|---|
| chart | No | One chart slug; omit for all five. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, so the bar is lower. The description adds real value by disclosing that each aggregate carries n, coverage, caveat, method, as-of date, and CSV/chart URLs, plus a CC BY 4.0 attribution obligation.
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 short sentences with no filler. The lead phrase 'The list in numbers' is slightly cute, but the concrete aggregate list and return metadata follow immediately and 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?
With no output schema and only one optional parameter, the description is nearly complete: it explains what each aggregate returns and notes licensing requirements. It could still clarify what 'the listed companies' means and when to prefer get_stats_history, but the core call context is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the enum slugs are largely self-explanatory. The description does map the five aggregates to the chart topics, but it adds no format or edge-case semantics beyond the schema's 'omit for all five' note.
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 resource (aggregate statistics for the listed companies) and enumerates the five aggregates, which clearly distinguishes it from single-record siblings like get_startup. It does not explain how it differs from get_stats_history, so sibling differentiation is only partial.
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 no explicit when-to-use guidance and never names an alternative such as get_stats_history. The only usage-shaped detail, omitting chart to get all five, is already stated in the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Quarterly snapshots of the same aggregates and one series per chart across snapshots. Never interpolated: one snapshot is one point. CC BY 4.0 with attribution.
| Name | Required | Description | Default |
|---|---|---|---|
| chart | No | One chart slug; omit for every series. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare a safe, idempotent read, so the description correctly spends its words elsewhere: it discloses the quarterly cadence, that values are never interpolated, that each snapshot is exactly one point, and that CC BY 4.0 attribution is required. Those are non-obvious traits an agent could not infer from the schema or annotations.
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 with little waste, but the lead sentence is a verbless fragment ('Quarterly snapshots of the same aggregates...') that delays comprehension. The license clause is relevant but competes with the missing core statement of what the tool returns.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description must carry return-shape information. It conveys the point-per-snapshot structure and per-chart series, but omits how far back the history goes, ordering, or the response container, leaving the agent to guess at the data's extent.
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%: the single `chart` enum parameter is already documented as 'One chart slug; omit for every series.' The description's 'one series per chart across snapshots' adds only marginal framing about how the parameter shapes output, so the 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?
The description indicates the resource is historical quarterly snapshots of the same aggregates as `get_stats`, but it is a noun phrase with no verb and never says it 'returns' or 'retrieves' anything. The reference to 'the same aggregates' only differentiates it from `get_stats` if the agent already knows what `get_stats` does.
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?
There is no explicit statement of when to call this instead of `get_stats` or the other siblings; the link to `get_stats` is implied through 'the same aggregates' rather than stated as an alternative. No prerequisites or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every security-company category with its slug, description, company count and page URL.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is fully covered. The description adds real value beyond that by disclosing the return shape and that the list is exhaustive ('every ... category'), which is the key behavioral fact for a zero-parameter enumerator.
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?
A single front-loaded sentence that names the resource and immediately lists the returned fields; there is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-param, read-only listing tool with no output schema, the description covers purpose and return fields adequately. Minor gaps remain on ordering of results and any limits, but nothing an agent needs to call it 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 takes no parameters, so the baseline is 4. Nothing in the description conflicts with the empty schema, and it correctly implies the result set is unfiltered and unpaginated.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (list) and resource (security-company categories) and even enumerates the returned fields (slug, description, company count, page URL). It is clearly distinct from the startup-oriented siblings, though it never explicitly names an alternative.
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?
Usage is only implied: an agent can infer this is the way to enumerate categories. There is no explicit when-to-use, when-not-to-use, or pointer to a sibling such as search_startups as the filtered counterpart.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the Security Startups directory of young security companies. Filters combine with AND. Returns public fields and each company's page URL, alphabetical by name (not a ranking).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Results to return, 1 to 50; larger values are capped at 50. | |
| query | No | Free text matched against name, summary, description, category, tags, HQ and investors. | |
| category | No | Category slug or name, e.g. application-security. See list_categories. | |
| funding_stage | No | Funding stage, e.g. Seed, Series A, Series C. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely non-obvious behavior: results are alphabetical by name and explicitly NOT a ranking, and only public fields plus a page URL are returned. Pagination beyond the limit cap is not addressed.
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 tight sentences: purpose first, then filter/return/ordering semantics. No filler, and the most decision-relevant facts (AND combination, non-ranking order) 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?
With full schema coverage and rich annotations, the remaining burden is small, and the description covers return shape and ordering even without an output schema. It leaves a gap around total result counts and paging for queries exceeding the 50-result cap.
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 per-parameter meaning is already documented, giving a baseline of 3. The description earns an extra point by stating that filters combine with AND, a cross-parameter interaction the schema does not express, and by clarifying the ordering of results relative to the limit parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Search') plus a named resource ('Security Startups directory of young security companies'), which is clearly distinguishable from get_startup (single record) and list_categories (taxonomy lookup). It does not explicitly name the siblings it is not, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies a filtered-directory lookup and explains that filters combine with AND, which guides invocation. However, it never states when to use this versus list_categories (to discover slugs) or get_startup (for full detail), leaving routing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
check_if_listedget_startupget_statsget_stats_historylist_categoriessearch_startups
Add one secure layer between your agents and this server.