Waddle Labs launches AI agents that write control code for robots

Why it matters

Waddle Labs is testing whether robotics can adopt coding agents' iterative workflow, reducing the task-specific data and manual engineering required to program new hardware.

Waddle Labs founders Hanming Ye (@DozenDucc) and Yiding "Vincent" Song (@yiding_song) launched an early-access API on July 27th that uses language-model agents to write control programs for robots. The founders describe the product as "Claude Code for robots" and claim it can produce a working policy from a natural-language prompt in 20 minutes.

https://x.com/dozenducc/status/2081802609128788393?s=46

Ye introduced Waddle Labs in a thread on X, showing an agent breaking physical tasks into steps, inspecting camera feeds and generating code that a robot can execute. The output is an editable program, allowing an operator to ask the agent for revisions instead of collecting another dataset and retraining a robot model.

The founders are Harvard College Class of 2028 students with research backgrounds that map directly to the product. Song studies computer science, mind-brain-behavior and physics, and researches in-context program induction at Harvard's Gershman Lab and Kempner Institute, according to his personal site. Ye authored a 2025 paper on steering diffusion-based robot policies without updating the underlying model's parameters.

Ye and Song started Waddle Labs in 2025 and are building it from Boston, according to Y Combinator's company directory. The two-person operation is part of YC's Summer 2026 batch. YC says every accepted company receives its standard $500,000 investment, split between $125,000 for 7% and $375,000 through an uncapped most-favored-nation SAFE.

Putting a coding agent above the robot model

Most robot foundation-model developers are training policies that convert images and instructions into actions. Physical Intelligence, for example, built its pi0 model using data gathered across multiple robot types and designed it to produce low-level motor commands. Figure describes Helix as a vision-language-action model that controls perception, movement and reasoning in real time.

Waddle Labs inserts a software agent above that control layer. Its agent writes code as the policy while retaining the ability to call vision-language-action models and other specialist systems as tools. Waddle Labs says this structure allows the same agent architecture to operate with different arms, grippers and camera setups without collecting fresh training data for each configuration.

According to Waddle Labs' technical launch post, the agent watches the robot's camera feeds, divides a goal into subtasks and verifies intermediate results. When an action fails, the agent can revise the program and try again. A coordinating agent can also create subagents to control multiple robots concurrently.

The generated programs draw from a shared hierarchy of primitives and higher-level skills. Waddle Labs says one agent created a fold_grasp skill while learning to flip a package, after which another agent reused it to fold a shirt. The bet is that deployed robots will leave behind useful code rather than isolated demonstrations: each completed task expands a library that later agents can combine into longer programs.

The benchmark remains an early company-run test

Waddle Labs says an agent produced a working policy for placing microswitches into slots in about 20 minutes. In another experiment, the system performed roughly 1,000 randomized Lego pick-and-place repetitions overnight and trained an ACT manipulation policy from the resulting data. Those results position the API as a tool for deployment, data collection and automated robotics research.

The founders also tested what Waddle Labs identifies as Opus 4.8, Fable 5 and GPT 5.6 Sol across a manipulation suite. Waddle Labs reported that larger models using larger reasoning budgets generated better policies, with only Fable 5 and GPT 5.6 Sol completing harder tasks such as folding a shirt under the tested settings.

The evidence comes from Waddle Labs' own hardware and task suite. Waddle Labs acknowledges that robot-agent results remain difficult to compare because labs use different machines, tasks and success criteria, and calls for standardized benchmarks. The API is being distributed through an early-access request rather than a public self-service product, making reproducibility across customer hardware the next test.

The approach also depends on general-purpose models being reliable enough to write code that safely controls physical equipment. Software agents can retry inside a sandbox; a robot may damage an object, collide with nearby equipment or create a hazardous state before an agent gets another turn. Waddle Labs' architecture keeps fixed platform primitives beneath generated skills, giving operators a potential control point for limiting what agent-written programs can execute.

Ye and Song have spent the past six months using agents to control robots, according to the technical post. Their larger wager is that improvements in language models can flow into robotics through better planning and code generation, without rebuilding an end-to-end control model for every new task. Waddle Labs now has to show that this software-style iteration loop holds up outside its own lab.