Neuronto ARD Registry: Agentic Resource Discovery (ARD) Index
Server Details
Neuronto ARD Registry: one search across every public ARD registry + 200,000+ verified MCP tools
- Status
- Healthy
- Uptime
- 99.0% over 59 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-06-18
- URL
- Repository
- neuronto/agentic-resource-discovery
- GitHub Stars
- 56
- Server Listing
- neuronto
TDQS
Scored across 4 tools
find_resource and find_tool are the only pair with adjacent purposes, but their descriptions draw a clear line (searching for a service/endpoint vs. searching individual tool signatures from live tools/list). publish_resource and registry_stats are unambiguously distinct. Minor residual overlap remains since both search tools take free-text queries and return ranked results.
All names are snake_case and mostly verb_noun (find_resource, find_tool, publish_resource), with registry_stats being a noun_noun read-only outlier that is still self-explanatory. The pattern is predictable enough that an agent can infer new tool names.
Four tools cover discovery of services, discovery of tools, publishing, and index metadata — a tight, well-scoped surface for a registry index with no filler. Each tool clearly earns its place within the 3-15 sweet spot.
The lifecycle is asymmetric: you can publish a resource but there is no update, delist/unpublish, or get_resource-by-id operation, and no way to inspect a single listing's details or verification status beyond search results. An agent that publishes something and later needs to correct or remove it hits a dead end, though search and stats coverage is solid.
Available Tools
4 toolsfind_resourceFind an agentic resourceARead-onlyIdempotentInspect
Search for an MCP server, skill, agent, API or other callable capability for a task, across this index and every other public ARD registry at once. Returns ranked matches with a relevance score, the endpoint to connect to, and which registries carry each result. The score is relevance only and is not a trust or safety rating. Filter by payment (free, payable, x402, mpp) and a maximum price per call: terms come from the publisher's manifest or the endpoint's own 402 answer, and the caller pays the provider directly. 2 free calls a day, then 0.1 USDC per call over x402 (or prepaid credits).
| Name | Required | Description | Default |
|---|---|---|---|
| kind | No | Restrict to one family of resource. Matching is normalised, so 'mcp-server' finds them under every media type in circulation, and 'a2a-agent' or 'agent' both reach A2A cards and ACP, OASF and AgentFacts descriptors. 'webmcp' is browser-page tools, which are not callable servers. | any |
| limit | No | ||
| query | Yes | The task, in plain language. For example: 'scrape a website behind cloudflare'. | |
| network | No | Payment network, for example base, solana, tempo or stripe. | |
| payment | No | Keep only resources with this payment requirement. 'free' means none is known; 'payable' means a price or a 402 is known. | any |
| federate | No | Also query upstream registries live and fuse the rankings. Off is faster. | |
| max_price_per_call | No | Most you will pay for one call, in US dollars. A resource whose price is unknown is excluded. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations: it discloses the return shape (ranked matches with relevance score, endpoint, and carrying registries), warns that the score is not a trust or safety rating, explains the provenance of price terms (publisher manifest or the endpoint's own 402 answer) and that the caller pays the provider directly, and states the rate/price model. That is exactly the context readOnlyHint/openWorldHint/idempotentHint cannot convey.
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?
Front-loaded with the search action and scope, then return shape, then the score caveat, then payment mechanics — a sensible priority order with no filler. It is dense to the point of being a long paragraph, and the payment sentence packs several distinct facts that an agent must unpack.
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 fully covers return values (ranked matches, score, endpoint, registries), the meaning of the score, and the cost model including the free tier — the things an agent needs before committing to a call. Federation behavior is only lightly covered ("at once" here, the faster-off note lives in the schema), but nothing blocking 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?
Schema coverage is 86%, so the schema already carries most parameter meaning; the description still adds value by explaining the payment filter categories and that price terms come from manifests or 402 answers, with direct provider payment. It does not touch limit, network, or federate, which are left entirely to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and a well-enumerated resource set ("MCP server, skill, agent, API or other callable capability") plus scope ("across this index and every other public ARD registry at once"), which is concrete enough to act on. It never names its closest sibling find_tool, so an agent cannot tell from the description alone which of the two to pick.
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 implied by "for a task" and by the filter guidance on payment ("free, payable, x402, mpp"), but there is no explicit when-to-use/when-not and no named alternative such as find_tool or registry_stats. The cost note ("2 free calls a day, then 0.1 USDC") does give the agent a practical budget consideration without saying what to do about it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_toolFind a specific verified toolARead-onlyIdempotentInspect
Search individual MCP tools by name and behaviour, not the servers that host them. Every tool returned here was read back from a live server's tools/list, so the name and input schema are what the server actually exposes rather than what its description claims. Use this when you know the shape of the call you need; use find_resource when you are looking for a service. 2 free calls a day, then 0.1 USDC per call over x402 (or prepaid credits).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | What the tool should do. For example: 'extract text from a pdf'. | |
| with_schema | No | Include each tool's full JSON input schema. Verbose; off by default. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare a safe read-only, idempotent, open-world profile, and the description adds genuinely new context: results are verified from a live server's tools/list, so names and input schemas are authoritative rather than claimed. It also discloses the billing model (2 free calls/day, then 0.1 USDC over x402 or prepaid credits), which annotations cannot express.
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?
Four short sentences, each carrying a distinct payload (provenance, differentiation, usage routing, cost), with the scope constraint front-loaded. Nothing is repeated from the title or schema.
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?
No output schema exists, but the description conveys what is returned (tools with authoritative names and input schemas, optionally full JSON schema via with_schema). Missing only explicit mention of result ordering or the effect of the limit parameter.
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 67% and the two optional parameters (limit, with_schema) are already documented in the schema itself, so the description adds little. It only implicitly frames the query as a description of desired behaviour, leaving the description to do no more than the schema already does.
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 ('Search individual MCP tools by name and behaviour') and immediately scopes it against the sibling concern ('not the servers that host them'). An agent can distinguish it from find_resource without opening any schema.
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?
Gives explicit when-to-use ('when you know the shape of the call you need') paired with the named alternative and its condition ('use find_resource when you are looking for a service'). It also discloses the cost model, which affects invocation decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
publish_resourcePublish a resource to the indexAIdempotentInspect
List an MCP server or an ARD-publishing domain in this index so other agents can discover it. Give endpoint for an MCP server URL, or domain for a site that serves an ARD manifest. The submission is verified before it is indexed: an endpoint must complete an MCP initialize handshake, and a domain must serve a manifest that parses. Nothing is taken on trust, so a listing that succeeds here is one an agent can actually call. Free submissions are reviewed and listed within 30 days. Set priority=true to list now for 5 USDC (x402).
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | A domain serving /.well-known/ard.json, e.g. example.com | |
| endpoint | No | Absolute URL of an MCP server, e.g. https://example.com/mcp | |
| priority | No | list now instead of after review (paid, x402) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations by disclosing the verification gate (MCP initialize handshake for endpoints, parsable manifest for domains), the 30-day review window for free submissions, and the 5 USDC x402 cost plus immediate-listing effect of `priority`. The annotations only tell the agent this is a non-destructive, idempotent, open-world write; the description supplies the actual consequences.
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?
Four sentences, front-loaded with the action and the parameter choice, then verification, then pricing. The 'Nothing is taken on trust' sentence is slightly rhetorical but does communicate that failed verification blocks indexing, so it mostly 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?
With no output schema, the description covers what gets checked, how long free review takes, and the paid fast path. It stops short of saying what the tool returns on submission (listing identifier, verification failure response), which is the only material gap for a create-style tool.
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 baseline is 3, but the prose adds real meaning: the endpoint must survive an initialize handshake, the domain must resolve /.well-known/ard.json and parse, and priority swaps review latency for a 5 USDC charge. That is semantic value beyond the schema's example strings.
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: adds an MCP server endpoint or ARD domain to the index so other agents can discover it. The two accepted resource kinds are named explicitly, which cleanly separates it from the read-only siblings find_resource, find_tool, and registry_stats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear selection logic: use `endpoint` for an MCP server URL, `domain` for a site serving an ARD manifest, and `priority=true` when you want paid immediate listing instead of the 30-day review. It does not explicitly contrast against the sibling lookup tools, but the when-to-use context is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
registry_statsIndex statisticsARead-onlyIdempotentInspect
How large this index is, what it holds, how much of it has been verified by introspection, and which upstream registries are federated.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context by specifying what the statistics cover and the concept of introspection verification. No side-effect or return-format disclosure, but annotations cover the safety profile.
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 sentence that packs four distinct aspects of the statistics without redundancy. It is front-loaded with 'How large this index is' and avoids filler.
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 read-only stats tool, the description covers what the operation tells you. There is no output schema, so a structured return format isn't specified, but the listed categories are sufficient for an agent to understand the tool's value. Minor gap: no explicit statement of the output representation.
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 zero parameters, so the schema is trivial. Per the baseline for parameterless tools, the description is not required to elaborate parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description enumerates the exact content of the statistics (size, contents, verification, federated registries), which makes the tool's purpose identifiable. It lacks an explicit action verb like 'return' or 'show', but the title and description together clearly indicate a stats/inspection tool, and it is distinct from the find_* siblings.
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 the tool is for retrieving index statistics, but does not state when to use it in preference to find_resource/find_tool, nor any exclusions. The purpose difference is obvious enough that an agent can infer usage, but explicit guidance is absent.
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.
1 tool update
- Changed
publish_resource1 field changed- added
Input schema / properties / priorityAdded value: +{ + "description": "list now instead of after review (paid, x402)", + "type": "boolean" +}
1 tool update
- Changed
find_resource3 fields changed- added
Input schema / properties / max_price_per_callAdded value: +{ + "description": "Most you will pay for one call, in US dollars. A resource whose price is unknown is excluded.", + "minimum": 0, + "type": "number" +} - added
Input schema / properties / networkAdded value: +{ + "description": "Payment network, for example base, solana, tempo or stripe.", + "type": "string" +} - added
Input schema / properties / paymentAdded value: +{ + "default": "any", + "description": "Keep only resources with this payment requirement. 'free' means none is known; 'payable' means a price or a 402 is known.", + "enum": [ + "any", + "free", + "payable", + "x402", + "mpp", + "card" + ], + "type": "string" +}
1 tool update
- Added
publish_resource
3 tool updates
- First observed
find_resource - First observed
find_tool - First observed
registry_stats
Related MCP Connectors
AI agent registry — search, discover, register, and connect agents via MCP.
Find, compare, and audit software for AI agents. Scored registry of tools and MCP servers.
A registry of AI agent tools — MCP servers, APIs, CLIs, SDKs — kept current by automated ingestion.
Find the right MCPs, tools and skills for any AI task - discovery over a 14k+ resource catalog.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server with 60 tools connecting AI assistants to Czech healthcare databases (SUKL, MKN-10, NRPZS) and global biomedical sources (PubMed, ClinicalTrials.gov, OpenFDA).1MIT
- FlicenseAqualityDmaintenanceCentral registry for AI tools with vector search and knowledge graph, enabling intelligent tool discovery, chaining, and execution via MCP.12-
- AlicenseAqualityAmaintenanceAn MCP server that enables querying rare-disease data from Orphanet, including disease nomenclature, cross-references, classifications, gene associations, HPO phenotypes, epidemiology, and natural history.19MIT

@neurynae/toolcairn-mcpofficial
AlicenseNot gradedqualityCmaintenanceMCP tool discovery for AI agents — find, compare, verify tools across 35+ registries.3MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.