Build a Skild S1 Robotics MCP Server for Autonomous Robot Task Orchestration in 2026

Skild AI's S1, launched August 25, 2026, demonstrated that robots can learn complex 10-minute tasks from a single human video demonstration with 66% success — no fine-tuning required. This changes the economics of robot programming: instead of weeks of custom training per task, you record a 2-minute video and S1 executes it.

This FastMCP server wraps S1's capabilities as MCP tools, giving AI agents the ability to teach robots new tasks, monitor execution in real-time, and coordinate multi-robot fleets. For teams building physical AI fleet workflows, this server bridges the gap between language-based agent planning and physical robot execution.

File 1: Skild S1 MCP Server (server.ts)

// server.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const SKILD_API_KEY = process.env.SKILD_API_KEY || "";
const SKILD_BASE = "https://api.skild.ai/v1";

async function skildRequest(endpoint: string, body: any): Promise<any> {
  const response = await fetch(`${SKILD_BASE}${endpoint}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${SKILD_API_KEY}`,
    },
    body: JSON.stringify(body),
  });
  if (!response.ok) throw new Error(`Skild API error ${response.status}`);
  return response.json();
}

const server = new McpServer({ name: "skild-s1-robotics", version: "1.0.0" });

// Tool 1: Learn Task from Video
server.tool(
  "learn_task_from_video",
  "Teach a robot a new task from a single human video demonstration using S1.",
  {
    video_url: z.string().describe("URL or path to demonstration video"),
    robot_id: z.string().describe("Target robot identifier"),
    task_name: z.string().describe("Human-readable task name"),
  },
  async ({ video_url, robot_id, task_name }) => {
    const result = await skildRequest("/tasks/learn", {
      video_url, robot_id, task_name,
      max_duration_seconds: 600,
    });
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  }
);

// Tool 2: Execute Task
server.tool(
  "execute_task",
  "Execute a learned task on a specific robot.",
  {
    task_id: z.string().describe("Learned task identifier"),
    robot_id: z.string().describe("Target robot identifier"),
  },
  async ({ task_id, robot_id }) => {
    const result = await skildRequest("/tasks/execute", { task_id, robot_id });
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  }
);

// Tool 3: Monitor Execution
server.tool(
  "monitor_execution",
  "Monitor real-time execution status of a running robot task.",
  {
    execution_id: z.string().describe("Execution identifier"),
  },
  async ({ execution_id }) => {
    const response = await fetch(`${SKILD_BASE}/tasks/monitor/${execution_id}`, {
      headers: { Authorization: `Bearer ${SKILD_API_KEY}` },
    });
    const result = await response.json();
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  }
);

// Tool 4: Fleet Status
server.tool(
  "fleet_status",
  "Get status of all robots in a fleet.",
  {
    fleet_id: z.string().describe("Fleet identifier"),
  },
  async ({ fleet_id }) => {
    const response = await fetch(`${SKILD_BASE}/fleets/${fleet_id}/status`, {
      headers: { Authorization: `Bearer ${SKILD_API_KEY}` },
    });
    const result = await response.json();
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Skild S1 Robotics MCP Server running on stdio");
}

main().catch(console.error);

File 2: Client Config

{
  "mcpServers": {
    "skild-s1": {
      "command": "npx",
      "args": ["-y", "tsx", "server.ts"],
      "env": { "SKILD_API_KEY": "your-key" }
    }
  }
}

Production Reality Check

S1's 66% success rate means the MCP server must include retry logic and human escalation. The fleet_status tool enables real-time monitoring across multiple robots. For teams running warehouse automation agents, this server bridges agent planning with physical execution.

Integration with Physical AI Fleets

The Skild S1 MCP server bridges the gap between AI agent planning and physical robot execution. In a typical deployment, a LangGraph orchestrator plans a multi-step task (e.g., "inspect warehouse aisle 3, pick items from shelf B, package and label"), then dispatches the physical execution steps to S1 via the MCP server.

The learn_task_from_video tool enables rapid task deployment: instead of programming each robot action manually, warehouse operators can record a video of themselves performing the task and upload it through the MCP interface. S1 extracts the task structure and generates motor commands for the target robot.

The fleet_status tool provides real-time visibility into robot availability, battery levels, and task queues. For teams running multi-robot coordination workflows, this tool is essential for load balancing and failure recovery.

Production deployments should implement health checks that verify task completion through computer vision (confirming the object was placed correctly) before marking a task as successful. This adds reliability on top of S1's 66% base success rate.

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with Skild S1 API, MCP SDK v1.12, TypeScript 5.6, and Node v22.