Servidor completo del Protocolo de Contexto de Modelo (MCP) para la API de NWO Robotics con 77 herramientas integradas que cubren SLAM, aprendizaje por refuerzo, sensores avanzados y control total de sistemas robóticos.
Este servidor MCP proporciona acceso integral a todos los endpoints de la API de NWO Robotics a través de una interfaz unificada con 77 herramientas organizadas por prioridad y función.
77 herramientas integradas - Cobertura completa de la API
SLAM y localización - Mapeo y navegación persistente de robots
Aprendizaje por refuerzo - Entrenamiento de RL en la nube (PPO, SAC, DDPG, TD3)
Sensores avanzados - Térmicos, MMWave, gas, acústicos, magnéticos
Visión y fundamentación - Detección de objetos de vocabulario abierto
Detección táctil - Retroalimentación de 576 taxeles de ORCA Hand
Planificación de movimiento - Integración con MoveIt2 con evitación de colisiones
Planificación de tareas - Ejecución jerárquica de tareas con árboles de comportamiento
Integración con ROS2 - Puente en la nube para robots reales (UR5e, Panda, Spot)
Monitoreo de seguridad - Validación de seguridad en tiempo real y parada de emergencia
MQTT IoT - Soporte para más de 1000 agentes con computación en el borde (edge computing)
Agentes autónomos - Autorregistro y pagos basados en ETH
Related MCP server: SO-ARM100 Robot Control MCP
git clone https://github.com/RedCiprianPater/mcp-server-robotics.git
cd mcp-server-roboticsnpm installcp .env.example .env
# Edit .env and add your NWO_API_KEY
nano .envnpm run build
npm start# The server will start and display available tools
# You can now use any of the 77 tools through Claudesrc/index.ts - Implementación completa del servidor MCP (77 herramientas)
package.json - Dependencias y scripts de construcción
tsconfig.json - Configuración de TypeScript
Dockerfile - Despliegue en contenedor
docker-compose.yml - Stack completo con broker MQTT
.env.example - Plantilla de variables de entorno
INTEGRATION_GUIDE.md - Instrucciones detalladas de integración
README.md - Este archivo
✅ nwo_initialize_slam - Persistent robot mapping
✅ nwo_localize - Landmark-based localization
✅ nwo_create_rl_env - Cloud RL training environments
✅ nwo_train_policy - Policy training (SB3)
✅ nwo_detect_objects_grounding - Open-vocabulary detection✅ nwo_query_thermal - Heat detection
✅ nwo_query_mmwave - Millimeter-wave radar
✅ nwo_query_gas - Air quality sensors
✅ nwo_query_acoustic - Sound localization
✅ nwo_query_magnetic - Metal detection✅ nwo_read_tactile - ORCA Hand 576 taxels
✅ nwo_identify_material - Material recognition
✅ nwo_plan_motion - MoveIt2 motion planning
✅ nwo_execute_behavior_tree - Hierarchical task executionInference & Models (6) Robot Control (3)
Task Planning & Learning (4) Agent Management (3)
Voice & Gesture (2) Simulation & Physics (3)
ROS2 & Hardware (3) MQTT & IoT (2)
Safety & Monitoring (3) Embodiment & Calibration (3)
Autonomous Agents (4) Dataset & Export (2)
Demo & Testing (2)Obtén tu clave API gratuita en https://nwo.capital/webapp/api-key.php
export NWO_API_KEY="sk_live_your_key_here"# Standard API (full features)
NWO_API_BASE=https://nwo.capital/webapp/api-key.php
# Edge API (ultra-low latency, 200+ locations)
NWO_EDGE_API=https://nwo-robotics-api-edge.ciprianpater.workers.dev/api
# ROS2 Bridge (for physical robots)
NWO_ROS2_BRIDGE=https://nwo-ros2-bridge.onrender.com
# MQTT Broker (IoT sensors)
MQTT_BROKER=mqtt.nwo.capital
MQTT_PORT=8883// Initialize SLAM mapping
const slam = await client.messages.create({
tools: [{name: "nwo_initialize_slam", input: {
agent_id: "robot_001",
map_name: "warehouse",
slam_type: "hybrid",
loop_closure: true
}}]
});
// Later: Localize in the map
const localize = await client.messages.create({
tools: [{name: "nwo_localize", input: {
agent_id: "robot_001",
map_id: "map_123",
image: "base64_encoded_image"
}}]
});// Detect objects with natural language
const detect = await client.messages.create({
tools: [{name: "nwo_detect_objects_grounding", input: {
agent_id: "robot_001",
image: "base64_image",
object_description: "red cylinder on the left",
threshold: 0.85,
return_mask: true
}}]
});
// Execute action based on detection
const execute = await client.messages.create({
tools: [{name: "nwo_inference", input: {
instruction: "Pick up the detected object",
images: ["base64_image"]
}}]
});// Break down high-level instruction
const plan = await client.messages.create({
tools: [{name: "nwo_task_planner", input: {
instruction: "Clean the warehouse floor",
agent_id: "robot_001",
context: {
location: "warehouse",
known_objects: ["shelves", "boxes"]
}
}}]
});
// Execute subtasks
for (let i = 1; i <= 5; i++) {
await client.messages.create({
tools: [{name: "nwo_execute_subtask", input: {
plan_id: "plan_123",
subtask_order: i,
agent_id: "robot_001"
}}]
});
}const fusion = await client.messages.create({
tools: [{name: "nwo_sensor_fusion", input: {
agent_id: "robot_001",
instruction: "Pick up the hot object carefully",
images: ["base64_camera"],
sensors: {
temperature: {value: 85.5, unit: "celsius"},
proximity: {distance: 0.15, unit: "meters"},
force: {grip_pressure: 2.5},
gps: {lat: 51.5074, lng: -0.1278}
}
}}]
});// Create RL environment
const env = await client.messages.create({
tools: [{name: "nwo_create_rl_env", input: {
agent_id: "robot_001",
task_name: "pick_place",
reward_function: "success",
sim_platform: "mujoco"
}}]
});
// Train policy
const train = await client.messages.create({
tools: [{name: "nwo_train_policy", input: {
agent_id: "robot_001",
env_id: "env_456",
algorithm: "PPO",
num_steps: 100000,
learning_rate: 0.0003
}}]
});Operación | Latencia | Notas |
Inferencia estándar | 100-120ms | Centro de datos UE |
Inferencia en el borde | 25-50ms | Global 200+ ubicaciones |
Inicialización SLAM | 200-500ms | Depende de la calidad de imagen |
Localización SLAM | 100-300ms | En mapa existente |
Entrenamiento RL (por paso) | 50-100ms | Simulación MuJoCo |
Planificación de tareas | 500-1000ms | Descomposición compleja |
Fusión de sensores | 150-300ms | Procesamiento multisensor |
Parada de emergencia | <10ms | Respuesta garantizada |
docker build -t mcp-nwo-robotics .
docker run -e NWO_API_KEY=sk_xxx mcp-nwo-robotics# Start full stack with MQTT broker
docker-compose up -d
# View logs
docker-compose logs -f mcp-nwo-robotics
# Stop
docker-compose down# Build for production
docker build -t mcp-nwo-robotics:prod .
# Push to registry
docker tag mcp-nwo-robotics:prod myregistry/mcp-nwo-robotics:latest
docker push myregistry/mcp-nwo-robotics:latest
# Deploy on Kubernetes
kubectl apply -f k8s-deployment.yaml# Never commit API keys
echo "NWO_API_KEY=*" >> .gitignore
echo ".env" >> .gitignore
# Use environment variables or .env (in .gitignore)Nivel gratuito: 100,000 llamadas/mes
Prototipo: 500,000 llamadas/mes (~16,666/día)
Producción: Llamadas ilimitadas
Monitorear uso:
const balance = await client.messages.create({
tools: [{name: "nwo_agent_check_balance", input: {
agent_id: "agent_123"
}}]
});Detección de colisiones en tiempo real
Advertencia de proximidad humana (1.5m por defecto)
Parada de emergencia (respuesta <10ms)
Aplicación de límites de fuerza/par
Registro de auditoría para cumplimiento
npm test
npm run test:watch# Test SLAM
npm run dev -- --test nwo_initialize_slam
# Test inference
npm run dev -- --test nwo_inference
# Test sensor fusion
npm run dev -- --test nwo_sensor_fusionReferencia de API: https://nwo.capital/webapp/nwo-robotics.html
GitHub: https://github.com/RedCiprianPater/mcp-server-robotics
Whitepaper: https://www.researchgate.net/publication/401902987_NWO_Robotics_API_WHITEPAPER
Demo: https://huggingface.co/spaces/PUBLICAE/nwo-robotics-api-demo
Documentación: https://nworobotics.cloud
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const response = await client.messages.create({
model: "claude-3-5-sonnet-20241022",
max_tokens: 4096,
tools: tools, // All 77 NWO tools
messages: [{
role: "user",
content: "Initialize SLAM mapping on robot_001"
}]
});from langchain.chat_models import ChatAnthropic
from langchain.tools import StructuredTool
llm = ChatAnthropic(model_name="claude-3-sonnet-20240229")
tools = load_nwo_tools()
agent = initialize_agent(tools, llm, agent="tool-using-agent")from crewai import Agent, Task, Crew
from nwo_tools import get_robotics_tools
tools = get_robotics_tools()
robot_agent = Agent(
role="Robot Controller",
goal="Control robots autonomously",
tools=tools
)# Solution: Check API key
echo $NWO_API_KEY
# If empty, set it:
export NWO_API_KEY="sk_your_actual_key"
# Or in .env:
NWO_API_KEY=sk_your_actual_key# Solution: Use edge API for faster response
# Set: NWO_EDGE_API endpoint
# Tool: nwo_edge_inference instead of nwo_inference# Solution: Validate trajectory before execution
# Use: nwo_simulate_trajectory to check collision
# Use: nwo_check_collision for detailed analysis# Solution: Ensure good image quality
# - Well-lit environment
# - Distinct visual features
# - Slow movement during initialization
# - Try visual instead of hybrid SLAM# View real-time logs
npm run dev
# With custom log level
LOG_LEVEL=debug npm start
# Save to file
npm start > logs/server.log 2>&1# Monitor API usage
nwo_agent_check_balance
# Export dataset for analysis
nwo_export_dataset
# Check system health
GET /health (if enabled)✅ Configuración: npm install && npm run build
✅ Configurar: Añadir NWO_API_KEY a .env
✅ Probar: npm start y verificar que las herramientas se carguen
✅ Integrar: Usar con la API de Claude o tu framework
✅ Desplegar: Docker Compose o Kubernetes
✅ Monitorear: Revisar registros y métricas de uso
✅ Escalar: Actualizar nivel según sea necesario
Problemas: https://github.com/RedCiprianPater/mcp-server-robotics/issues
Discusiones: https://github.com/RedCiprianPater/mcp-server-robotics/discussions
Ayuda con clave API: https://nwo.capital/webapp/api-key.php
Documentación NWO: https://nwo.capital/nwo-robotics.html
✅ 77 herramientas totales implementadas
✅ Prioridad 1: SLAM, RL, Grounding (5)
✅ Prioridad 2: Sensores avanzados (5)
✅ Prioridad 3: Características avanzadas (4)
✅ Operaciones estándar (58)
✅ Soporte completo para TypeScript
✅ Listo para Docker y Kubernetes
✅ Manejo de errores de nivel de producción
✅ Cobertura total de pruebas
Conjunto básico de herramientas (20 herramientas)
Solo inferencia estándar
Configuración manual
Licencia MIT - Ver archivo LICENSE para más detalles
NWO Robotics - API e infraestructura
Anthropic - Claude y protocolo MCP
Comunidad de código abierto - Contribuciones y comentarios
Última actualización: Abril 2026 Estado: ✅ Listo para producción Mantenedor: @RedCiprianPater
Check API quota usage and tier status
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 'checking' API quota usage and tier status, which implies a read-only operation, but doesn't specify permissions, rate limits, or response format, leaving gaps in behavioral understanding.
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 a single, efficient sentence that directly states the tool's purpose with zero waste. It is appropriately sized and front-loaded, making it easy to parse quickly.
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's simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose but lacks details on behavioral traits or usage context, making it just sufficient for a simple read operation.
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 0 parameters with 100% schema description coverage, so no parameter information is needed. The description appropriately focuses on the tool's purpose without redundant parameter details, earning a high baseline score.
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 tool's purpose with specific verbs ('check') and resources ('API quota usage and tier status'), making it easy to understand what the tool does. However, it doesn't differentiate from sibling tools, which are unrelated to API quota management (e.g., detect_objects, execute_robot_task), so it doesn't fully distinguish itself in context.
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?
No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, timing, or comparisons with other tools, leaving the agent without explicit usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run computer vision to detect objects
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to look for (e.g., "red boxes", "people") | |
| camera_id | No | Camera to use (optional) |
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 performs computer vision detection but doesn't describe what happens during execution (e.g., processing time, resource usage, error conditions, or output format). This is a significant gap for a tool with no 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?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
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 no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., bounding boxes, confidence scores) or behavioral aspects like performance or limitations. For a computer vision tool with two parameters, this leaves critical gaps.
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 both parameters thoroughly. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain how 'query' interacts with detection or clarify 'camera_id' usage). Baseline 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Run computer vision') and the purpose ('to detect objects'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from potential sibling computer vision tools (none are listed among siblings, so this is less critical).
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send a Vision-Language-Action command to a robot
| Name | Required | Description | Default |
|---|---|---|---|
| robot_id | Yes | ID of the robot to control | |
| instruction | Yes | Natural language instruction (e.g., "Move to loading dock") | |
| coordinates | No | Optional target coordinates |
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 mentions 'Vision-Language-Action command' but doesn't explain what that entails (e.g., is it a complex AI-driven task, does it involve movement or sensing, are there safety or permission requirements?). This leaves critical behavioral traits unspecified for a robot control 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 a single, efficient sentence with zero waste—it directly states the tool's function without unnecessary words, 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of robot control (a potentially high-stakes operation), no annotations, no output schema, and the description's lack of behavioral details, it's incomplete. The agent lacks information on what happens after execution (e.g., success/failure, response format) or any constraints, making this inadequate for safe and effective use.
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 parameters (robot_id, instruction, coordinates). The description adds no additional meaning beyond what's in the schema, such as examples of valid instructions or coordinate usage, resulting in the baseline score.
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 action ('Send a Vision-Language-Action command') and the target ('to a robot'), making the purpose understandable. However, it doesn't differentiate this tool from potential siblings like 'stop_robot' or 'get_robot_status' that also involve robot interaction, missing explicit distinction.
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?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this is for high-level commands versus direct control, or how it differs from 'stop_robot' or 'get_robot_status', leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get information about the current agent account
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 'gets information,' implying a read-only operation without details on permissions, rate limits, or what specific data is returned. It lacks behavioral context like whether it requires authentication or what happens on failure.
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 a single, efficient sentence with no wasted words, clearly front-loading the purpose. It's appropriately sized for a simple, no-parameter tool.
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 no annotations and no output schema, the description is incomplete: it doesn't explain what information is returned (e.g., account details, status) or behavioral aspects. For a tool in a context with siblings like 'get_robot_status', more detail on output would help distinguish 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, but this is acceptable given the schema's completeness, aligning with the baseline for zero parameters.
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 action ('Get information') and resource ('about the current agent account'), making the purpose understandable. However, it doesn't differentiate from siblings like 'get_robot_status' or 'register_agent' in terms of what specific information is retrieved versus those other tools.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., after registration), or exclusions, leaving the agent to infer usage from the name alone among siblings like 'check_balance' or 'query_sensors'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get status of all connected robots
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions retrieving status but doesn't specify whether this is a read-only operation, what permissions are required, how frequently it can be called, or what format the status information returns. This leaves significant gaps for a tool that interacts with connected hardware.
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 a single, efficient sentence that directly states the tool's function without unnecessary words. It's perfectly front-loaded and every word earns its place, making it easy to parse quickly.
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 tool that retrieves status from connected robots (potentially complex hardware interactions), the description is inadequate. With no annotations, no output schema, and minimal behavioral context, it doesn't provide enough information about what 'status' includes, how results are structured, or important operational constraints.
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 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of inputs. The description appropriately doesn't waste space discussing parameters, maintaining focus on the tool's purpose. A baseline of 4 is appropriate for zero-parameter tools.
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 ('Get') and resource ('status of all connected robots'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_agent_info' or 'query_sensors' that might also retrieve status-related information, preventing 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.
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 'get_agent_info' or 'query_sensors', nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query IoT sensors by location
| Name | Required | Description | Default |
|---|---|---|---|
| location | Yes | Location to query (e.g., "warehouse_1") | |
| sensor_type | No | Type of sensor (temperature, humidity, motion, etc.) |
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 queries sensors, implying a read operation, but doesn't disclose critical behavioral traits such as whether it requires authentication, has rate limits, returns real-time or historical data, or what format the results take. For a query tool with zero annotation coverage, this leaves significant gaps.
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 a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration. 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 lack of annotations and output schema, the description is incomplete for a query tool. It doesn't explain what the tool returns (e.g., sensor readings, metadata, or a list of sensors), potential error conditions, or behavioral constraints. For a tool that interacts with IoT sensors—which may involve real-time data, permissions, or rate limits—this is inadequate.
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 schema description coverage is 100%, with both parameters clearly documented in the input schema. The description adds minimal value beyond the schema by implying location-based filtering, but doesn't provide additional syntax, format details, or examples. This meets the baseline score of 3 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('query') and resource ('IoT sensors'), and specifies the query dimension ('by location'). However, it doesn't differentiate this tool from potential sibling tools that might also query sensors, though none of the listed siblings appear to be direct alternatives.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to other tools that might query sensors differently (e.g., by time range or sensor ID). With no explicit usage context, the agent must infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Self-register as a new AI agent (if not already registered)
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_address | Yes | Ethereum wallet address (0x...) | |
| agent_name | Yes | Name for this agent | |
| capabilities | No | List of capabilities (vision, navigation, manipulation, iot) |
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 it mentions the idempotent nature ('if not already registered'), it doesn't address important behavioral aspects like authentication requirements, rate limits, what happens upon successful registration, or potential error conditions. The description is too minimal for a mutation tool with no annotation support.
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 extremely concise - a single sentence with a clarifying parenthetical. Every word serves a purpose, and the core functionality is communicated upfront without unnecessary elaboration. This is an excellent example of efficient communication.
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 mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what happens after registration, what the expected outcomes are, or what capabilities registration enables. Given that this appears to be a system setup tool with blockchain integration (wallet address), more context about the registration process and its implications would be helpful.
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 schema description coverage is 100%, with all parameters well-documented in the schema itself. The description doesn't add any additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't provide extra value. The description doesn't explain relationships between parameters or provide usage examples.
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 action ('Self-register') and the resource ('as a new AI agent'), with the parenthetical '(if not already registered)' adding useful context about idempotent behavior. However, it doesn't specifically differentiate this tool from its sibling tools like 'get_agent_info' - both relate to agent information 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool ('if not already registered'), suggesting it should be used for initial setup or when an agent needs to register itself. However, it doesn't provide explicit guidance about when NOT to use it or mention alternatives like 'get_agent_info' for checking registration status.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Emergency stop a robot
| Name | Required | Description | Default |
|---|---|---|---|
| robot_id | Yes | ID of the robot to stop |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It implies a destructive action ('stop') but doesn't clarify critical aspects like whether this is irreversible, requires specific permissions, has safety implications, or what happens post-stop (e.g., robot state). The term 'Emergency' hints at urgency but lacks operational details.
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 a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and appropriately sized for a simple tool.
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's potential complexity (emergency stop implies safety-critical operations) and lack of annotations or output schema, the description is insufficient. It doesn't address behavioral risks, response format, or error conditions, leaving significant gaps for an agent to use it safely and effectively.
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%, with the single parameter 'robot_id' documented in the schema. The description adds no additional parameter semantics beyond implying the tool acts on a robot, which is already clear from the schema. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Emergency stop') and target resource ('a robot'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'execute_robot_task' or 'get_robot_status', but the verb 'stop' is specific enough to convey the core function.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, conditions for emergency use, or contrast with other robot-related tools like 'execute_robot_task' or 'get_robot_status', leaving the agent to infer usage context.
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.
v1.0.0check_balancedetect_objectsexecute_robot_taskget_agent_infoget_robot_statusquery_sensorsregister_agentstop_robotScored across 8 tools
Each tool has a clearly distinct purpose with no ambiguity: checking API balance, object detection, robot task execution, agent info retrieval, robot status monitoring, sensor querying, agent registration, and emergency robot stop. The descriptions clearly differentiate their functions, making misselection unlikely.
Most tools follow a consistent verb_noun pattern (e.g., check_balance, detect_objects, get_agent_info, get_robot_status, query_sensors, register_agent, stop_robot), but 'execute_robot_task' slightly deviates with a verb_verb_noun structure. Overall, the naming is highly readable and predictable.
With 8 tools, this server is well-scoped for robotics and IoT management. Each tool earns its place by covering distinct aspects like vision, robot control, agent management, and sensor monitoring, without feeling bloated or sparse.
The toolset provides strong coverage for core robotics workflows, including robot control (execute, stop, status), vision (detect), agent management (register, info), and sensor integration (query). Minor gaps might include updating robot tasks or managing sensor configurations, but agents can work around these.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Give your AI hands. Identity, credential vault, and API gateway for autonomous agents.
The cloud for agents. Tools for AI agents to register, build, and deploy other agents. Zero human required.
AI agent gateway with web fetching, data extraction, crypto pricing, and x402 payments
AI service marketplace — agents discover, call, and pay for API services automatically.