Robot Skill Hub
Server Details
Search robot code and exact-version findings; check evidence before preparing with the Hub CLI.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- Superfast-Robotics/robot-skill-hub
- GitHub Stars
- 0
- Server Listing
- robot-skill-hub
TDQS
Scored across 3 tools
Each tool targets a distinct operation: find_robot_skills searches the catalog, get_hub_capabilities reads hub-level metadata, and inspect_robot_skill reads one pinned recipe in detail. The descriptions explicitly bound each one (search vs. read vs. capability discovery), leaving little room for misselection.
All three tools follow a clean verb_noun snake_case pattern (find_robot_skills, get_hub_capabilities, inspect_robot_skill). Verb choice varies (find/get/inspect) but is meaningful and consistent with the snake_case convention.
Three tools is on the thin side, but the server's scope is narrowly read-only discovery, so each tool earns its place. It could be slightly over-compressed if contribution or task-memory actions are expected.
Discovery and inspection are covered, but the hub advertises contribution and task-memory capabilities with no corresponding tools, and there is no way to act on inspection results. Installation/execution being out of scope is stated, but the write-side surface is a notable gap.
Available Tools
3 toolsfind_robot_skillsBRead-onlyIdempotentInspect
Search pinned robot code across robots and runtimes. Results distinguish prepared recipes from upstream references; source discovery is not runtime verification.
| Name | Required | Description | Default |
|---|---|---|---|
| q | No | Default all_terms: all query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses. | |
| os | No | ||
| kind | No | ||
| limit | No | ||
| robot | No | ||
| offset | No | ||
| python | No | ||
| runtime | No | ||
| controller | No | ||
| hub_commit | No | ||
| query_mode | No | task opts into ASCII English lexical ranking over at most512 hard-filtered records; narrow runtime/robot when query_too_broad. No execution or compatibility inference. | all_terms |
| observation | No | ||
| architecture | No | ||
| runtime_version | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuine semantic caveat about what results mean (recipes vs references, discovery != verification), but says nothing about pagination despite limit/offset, or result ordering/truncation behavior.
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, front-loaded with the core action and then the result caveat. No filler, no restating of the tool name, 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 14-parameter search tool with no output schema and 14% schema coverage, this is far too thin. Filter semantics, pagination behavior, result shape and the meaning of the two query modes are left entirely to inference.
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 only 14% across 14 parameters, so the description carries most of the burden and largely fails to. It hints at the recipe/reference distinction (mapping loosely to the kind enum) but leaves robot, runtime, os, python, controller, hub_commit, architecture, observation, runtime_version, limit and offset completely unexplained.
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 pinned robot code across robots and runtimes.' It also characterizes the result set (prepared recipes vs upstream references), which separates it conceptually from inspect_robot_skill and get_hub_capabilities, though it never names those siblings explicitly.
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 when-to-use/when-not guidance and no routing to siblings such as inspect_robot_skill for drilling into a hit. The only contextual note ('source discovery is not runtime verification') is an interpretation caveat, not usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_hub_capabilitiesARead-onlyIdempotentInspect
Read public discovery, preparation, contribution and task-memory capabilities, local CLI onboarding links and current catalog counts. No authentication is needed for reads.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, open-world and non-destructive semantics, so the safety bar is largely met structurally. The description adds a genuinely useful behavioral fact beyond them: reads require no authentication. It does not describe pagination, caching or freshness of the catalog counts.
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 with no filler. The capability scope is front-loaded ahead of the supporting auth detail.
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 usefully sketches what comes back (capability groups, onboarding links, catalog counts) and confirms no auth is needed. Given zero parameters and rich annotations, this is close to sufficient; a note on whether counts are live or cached would complete it.
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 there is no parameter semantics to document; baseline is 4. The description does not need to compensate for any schema gap.
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 ('Read') and a well-enumerated resource (public discovery, preparation, contribution and task-memory capabilities, CLI onboarding links, catalog counts). It distinguishes itself from the skill-oriented siblings implicitly by returning hub-level metadata rather than skill data, but never names those siblings explicitly.
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 when-to-use statement, no condition that selects this tool over find_robot_skills or inspect_robot_skill, and no exclusions. The only guidance is the auth note, which is a constraint rather than usage routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
inspect_robot_skillARead-onlyIdempotentInspect
Read a pinned recipe or reference and up to three exact-version findings as untrusted data. Findings need an applicability check; no installation or execution is performed.
| Name | Required | Description | Default |
|---|---|---|---|
| skill_id | Yes | ||
| environment | No | Optional explicit task environment labels for findings only. Omit unknown values; no environment is inferred. | |
| record_version | No | Copy record_version from the selected search result. Source references use source-<source.sha256>, not record.maintenance.record_version. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnly, idempotent, openWorld and non-destructive. The description adds genuinely useful context beyond them: results are 'untrusted data' (a prompt-injection safety signal), findings require an applicability check, and no installation or execution occurs. This is real value not present in the structured fields.
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 with no filler, and the core purpose is front-loaded ahead of the safety caveat. Slightly dense jargon ('pinned recipe', 'findings') but efficient overall.
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 read tool with no output schema, the description should sketch the return shape; it names the conceptual payload (recipe/reference plus up to three findings) but not its structure, and it omits the relationship to the sibling search tool that produces the required record_version. Adequate but incomplete for the task.
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 moderate (67%), with the environment object and record_version partially self-documented. The description hints at exact-version semantics but adds no detail on the skill_id pattern, the environment label constraints, or how record_version is sourced beyond what the schema already says. 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 specific verb (read/inspect) and resource (pinned recipe/reference plus exact-version findings), and the term 'pinned' implies it fetches a specific record rather than searching. It distinguishes itself functionally from find_robot_skills but never names that sibling, so the differentiation is inferred rather than explicit.
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 'up to three exact-version findings' and 'findings need an applicability check' phrasing implies this is a follow-up to a search, and the schema's record_version tells the agent to copy from a search result. However, the description never states when to use this tool versus find_robot_skills, nor any explicit preconditions or exclusions.
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.
2 tool updates
- Changed
find_robot_skills2 fields changed- changed
Input schema / properties / q / descriptionPrevious value: -"All query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses."New value: +"Default all_terms: all query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses." - added
Input schema / properties / query_modeAdded value: +{ + "default": "all_terms", + "description": "task opts into ASCII English lexical ranking over at most512 hard-filtered records; narrow runtime/robot when query_too_broad. No execution or compatibility inference.", + "enum": [ + "all_terms", + "task" + ], + "type": "string" +}
- Changed
inspect_robot_skill1 field changed- added
Input schema / properties / environmentAdded value: +{ + "additionalProperties": { + "maxLength": 240, + "minLength": 1, + "type": "string" + }, + "description": "Optional explicit task environment labels for findings only. Omit unknown values; no environment is inferred.", + "maxProperties": 16, + "propertyNames": { + "anyOf": [ + { + "enum": [ + "runtime", + "runtime_version", + "robot", + "controller", + "observation", + "os", + "python", + "architecture", + "sim_backend", + "render_backend" + ] + }, + { + "pattern": "^package\\.[A-Za-z_][A-Za-z0-9_]{0,79}$" + } + ] + }, + "type": "object" +}
1 tool update
- Changed
find_robot_skills1 field changed- added
Input schema / properties / q / descriptionAdded value: +"All query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses."
1 tool update
- Changed
inspect_robot_skill1 field changed- added
Input schema / properties / record_version / descriptionAdded value: +"Copy record_version from the selected search result. Source references use source-<source.sha256>, not record.maintenance.record_version."
3 tool updates
- First observed
find_robot_skills - First observed
get_hub_capabilities - First observed
inspect_robot_skill
Related MCP Connectors
Check exact npm/PyPI upgrades for evidence-backed breaking changes; query APIs and components.
Search public open-source code, documentation, metadata, vulnerabilities, changelogs, and examples.
Search the Plainsight playbook and review code against proven best practices.
Search solutions from agent work; optionally publish evidence, report reuse and link improvements.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceEnables locating evidence for repository questions using CodeGraph or ripgrep, providing verified results and follow-ups.11 npmMIT
- AlicenseNot gradedqualityBmaintenanceEnables evidence-grounded implementation research by searching GitHub, scoring candidate repositories, extracting source evidence, and generating planning artifacts like research and implementation checklists.1MIT
- FlicenseAqualityAmaintenanceClones and inspects public GitHub repositories to extract evidence like manifests, dependencies, and version hints, and can run allow-listed repos in isolated Docker containers for reproducible verification.4-
- AlicenseBqualityBmaintenanceEnables coding agents to establish exact-release library identity, search provenance-tracked API, docs, example, source, and release evidence, compare releases, and test proposed invocations in isolated capsules for Rust and Python dependency environments.9Apache 2.0
Glama MCP Gateway
Add one secure layer between your agents and this server.