RoboScript

Inspiration Programming a robot today means knowing Modbus register addresses, UR Script syntax, or ROS2 topic names before writing a single line of code. That's a barrier that keeps robotics locked inside a small circle of specialists. We wanted to ask: what if anyone could describe a task in plain language and get runnable robot code back — for any robot, any protocol?

What it does RoboScript is a universal robot programming agent. You describe what you want the robot to do in plain language — "pick up the part with 20N of force, hold for one second, then release gently" — and the agent produces executable control code for your specific robot and protocol. It supports Modbus TCP, UR Script, G-code, ROS2, and REST APIs out of the box. It also ships a config extractor: paste your robot's documentation and the agent automatically generates the communication descriptor, making any robot programmable in under a minute.

How we built it We built RoboScript on Vercel's Workflow Development Kit (WDK) with four durable steps: intent parsing via generateObject with the Anthropic API, safety validation against the robot's declared limits, code generation through a pluggable adapter system (one adapter per protocol), and a 2D simulation frame builder. The frontend was scaffolded with v0 and deployed on Vercel. Robot descriptors are Zod-validated JSON schemas that abstract away every protocol detail — the workflow never sees raw documentation, only structured capabilities and limits.

Challenges we ran into The hardest problem was designing an abstraction layer that could translate the same natural language intent into five different protocols without hardcoding any of them. A "grip" action means writing three Modbus registers in sequence for the OnRobot 2FG7, a movel() call in UR Script for a Universal Robots arm, and a G1 command for a CNC machine — the same concept, completely different outputs. Getting the LLM to stay strictly within the declared capabilities of each robot (instead of hallucinating commands that don't exist) required careful prompt engineering with the descriptor as grounding context.

Accomplishments that we're proud of The config extractor is the thing we're most proud of. Paste any robot's API reference or datasheet section — even an informal description — and the agent extracts a fully structured, Zod-validated descriptor that the rest of the system can immediately use. It turns robot onboarding from a multi-hour manual process into a 30-second interaction. We're also proud of the safety validation layer: the workflow distinguishes between soft warnings and hard stops, so the agent never generates code that would exceed a robot's physical limits.

What we learned Building with WDK changed how we think about AI agents. The durable step model — where each checkpoint survives crashes and deploys — is a fundamentally different mental model from a single LLM call. It forced us to think about which parts of the pipeline need to be resumable and which state needs to persist between steps. We also learned that structured output (generateObject with Zod schemas) is the right abstraction for agent-to-adapter communication: it turns a probabilistic LLM into a reliable data transformer.

What's next for RoboScript Direct execution — instead of exporting code, the agent sends commands to the robot in real time over the network, with the WDK workflow handling retries and timeouts. A community preset marketplace where robotics teams can publish and share verified robot descriptors. A team workspace with script history and version control. And a real-time safety monitor that reads the robot's status registers during execution and pauses the workflow if something unexpected happens.

Built With

• ai
• anthropic
• claude
• kv
• next.js
• sdk
• tailwind
• typescript
• vercel
• workflow
• zod