---
license: apache-2.0
pretty_name: Microduck driven by Hermes Agent (simulation runs)
tags:
- robotics
- hermes-agent
- agents
- tool-use
- microduck
- pollen-robotics
- mujoco
- simulation
size_categories:
- n<1K
---

# Microduck driven by Hermes Agent: simulation runs

One sentence typed to [Hermes Agent](https://github.com/NousResearch/hermes-agent), and a [Pollen Robotics Microduck](https://github.com/pollen-robotics) does it. Hermes Agent picks and runs every command itself. This dataset logs every such run: the sentence, the agent's full transcript, the simulator's ground truth, the robot daemon's own monitor, and a replay video.

**Simulation only. Not yet tested on a real Microduck.** The simulator runs Pollen's real robot daemon (`robotd`), so the commands, the safety layer and the control loop are the ones the physical robot uses. Only the body is simulated.

Sibling dataset: [witcheer/microduck-skill-tree](https://huggingface.co/datasets/witcheer/microduck-skill-tree) (the RL policies we train for the same robot). Collection: [microduck skill tree (sim only)](https://huggingface.co/collections/witcheer/microduck-skill-tree-sim-only-6ab195da0c0b293bdccc6d34).

## How a run works

- Hermes Agent runs on the same Linux box as the simulator, on a local model (Qwen3.8-27B Q6_K through llama.cpp, one RTX 5090). No cloud model.
- It gets one skill, [`tools/microduck-sim-SKILL.md`](tools/microduck-sim-SKILL.md), and the terminal tool. The skill tells it about one command-line client, [`tools/duckctl.py`](tools/duckctl.py), with seven commands: health, status, stand, sit, walk, look, stop.
- The client only sends intents to `robotd` over its unix socket (JSON-RPC 2.0). It never touches a motor. `robotd` owns the motors and the safety layer, and zeroes the velocity if walk commands stop for 500 ms.
- `robotd` does not limit velocity itself, so the client refuses anything outside the ranges the walking policy was trained on (vx ±0.4 m/s, vy ±0.3 m/s, yaw ±1.0 rad/s).
- Ground truth comes from the simulator: [`tools/duck-state-rec.py`](tools/duck-state-rec.py) polls the MuJoCo body server's read-only `read` op at 30 Hz. [`tools/duck-replay-render.py`](tools/duck-replay-render.py) replays that state offscreen, so every video is the simulator's exact state, not a re-simulation.
- The client is ours. Pollen ships a different app also called `duckctl`, so treat this name as local to these runs.

## Runs

| run | start posture | tool calls, in order | walked (sim truth / robot odometry) | time | outcome |
|---|---|---|---|---|---|
| 2026-09-24 walk-then-sit take 1 | standing | health, walk, sit, status | 0.582 m / 0.555 m | 29.1 s (cold model) | pass |
| 2026-09-24 walk-then-sit take 2 | sitting | health, walk, stand, walk, sit, status | 0.577 m / 0.545 m | 32.8 s | pass after self-correction |
| 2026-09-24 walk-then-sit take 3 | sitting | health, stand, walk, sit, status | 0.578 m / 0.547 m | 21.6 s | pass |

The sentence was "make the duck walk forward for five seconds then sit" in all three. Time runs from the first to the last message in the session, and take 3 took 24.4 s wall clock from the sentence to the answer. Walk is `--vx 0.3 --seconds 5` every time.

What the runs taught us:

- **Take 1:** the final answer quoted the robot's odometry x (measured since the daemon started) as "distance from start". The skill now says to report deltas only.
- **Take 2:** `health` printed `robot.mode = walk`, which is the locomotion hardware mode, not posture. The model read it as standing and sent a walk to a seated duck. The walk output showed an odometry delta of 0.0 and policy `sit`, so it stood the duck up and walked again. After this run, `health` prints `posture` (the policy label) and `hardware_mode`.
- **Take 3:** after that fix, the model went straight to stand from the seated start. This is the take in the [X post](https://x.com/witcheer/status/2103024788897706203).

## What is in a run folder

- `run.json`: sentence, agent and model, client version, start posture, the tool-call sequence, distances, outcome, and a note on what the run showed.
- `transcript.json` / `transcript.md`: the full Hermes Agent session, with the user sentence, the model's reasoning, every tool call with its arguments, and every tool output. The system prompt is removed; everything else is verbatim.
- `state.jsonl`: simulator ground truth at 30 Hz (wall time, sim time, trunk position, trunk quaternion, 14 joint positions in robotd wire order).
- `monitor.log`: robotd's own monitor at 2 Hz (requested vs applied velocity, active policy, deadman).
- `replay.mp4`: an offscreen MuJoCo replay of `state.jsonl`, fixed camera, real time.

## Reproduce

Pollen's `microduck` repo at `6507d2e` (`scripts/duck-sim up`) plus Hermes Agent with the skill installed under `~/.hermes/skills/robotics/microduck-sim/`. [`tools/duck-p1-exit.sh`](tools/duck-p1-exit.sh) runs one sentence with the recorder and monitor attached, and [`tools/hermes-run-export.py`](tools/hermes-run-export.py) exports the session. The scripts carry `/home/witcheer` paths from the box they ran on; change them for yours.

## Limits

- Simulation only. The real robot is not here yet. When it is, the same client points at it over ssh (`--ssh-host`), and those runs will be labelled separately.
- One sentence and three takes so far. This is a run log, not a benchmark.
- Local model output varies between runs. The transcripts are what happened, not a best-of selection: every run of this sentence is here.