evolvBot

Today's AI agents think and act in software. evolvBot gives them hands.

Perception and reasoning have outrun embodiment. evolvBot is the platform where an agent doesn't just use a fixed body — it designs, fabricates, and grows the body it needs to finish a job, then tests the result against reality.

An agent that extends its own reach, in simulation.

The smallest honest slice of the vision. A minimal robot body has a target it cannot reach. Claude imagines a bolt-on extension; a PyBullet simulator tests it; the result feeds back; the agent refines until it reaches — one closed loop, need → design → test → evolve.

A single revolute joint with a straight rigid extension can't change its radius — the effective tip traces a circle of radius L + d. To hit a target at radius R, the agent must design d ≈ R − L: too short and too long both miss. That forces precision (not "long enough"), makes both error directions meaningful feedback, and makes minimizing material a real objective.

Six small units, each with one job and a clean interface. The Claude call sits behind a Designer protocol, so the whole loop runs — and is fully tested — with no API key.

Ranges are validated client-side with Pydantic (the structured-output API ignores min/max); an invalid or unbuildable spec becomes a failed attempt with feedback, never a crash. The reach test is a deterministic θ-sweep (1° steps) over the joint range — no IK solver — so it's trivially unit-testable.

• claude-opus-4-8 via the Python anthropic SDK.
• Structured output — messages.parse(output_format=PartSpec); every proposal is a validated spec.
• Adaptive thinking — thinking={"type":"adaptive"}, effort="medium" for the "imagining."
• Prompt caching — the stable system prompt is cached; only the per-iteration attempt history varies.
• Feedback — each round, a plain-language critique derived from TestResult ("short by 8.2 cm", "overshot by 3.0 cm").

FakeDesigner returns scripted specs, so loop, sim, and part are tested offline, $0, CI-safe: d=15cm → reached, d=5cm → short, d=30cm → overshoot; [short, correct] → reaches on iteration 2. The only non-deterministic seam — ClaudeDesigner — is one key-gated smoke test.

• Loop closes on a real reach in ≤ 6 iterations with ClaudeDesigner.
• Every iteration logs the spec + rationale + feedback.
• Exports a print-ready .stl of the winning part and a GIF of the reach.
• Deterministic tests pass with no network access.

All tooling is free/open-source; the only metered cost is the Claude API — a few cents per full run, $0 on the offline FakeDesigner path.

Built end-to-end in simulation — it finds the remote and puts it back.

The full loop runs as one pipeline: perceive → navigate → evolve the arm (within budget) → grasp → place. The minimal robot can't reach the floor, so it designs a longer arm, orders the parts, swaps it on, and finishes the job — all offline, $0, with 51 tests green.

Then we made the contact real — and taught it to clean a window.

We ported the world to MuJoCo so grasping is physical, not a kinematic weld: the jaws close, friction carries the object, gravity settles it. Two new acceptance tasks prove it — both shown here from the robot's own onboard camera. The arm is a plain serial chain — a shoulder yaw, then shoulder, elbow and wrist pitch joints — with a dark housing on each hinge so you can see exactly where it pivots.

Now we're building it — a real machine you can print and bolt together.

The simulation above is the digital twin of a physical robot, part-for-part. The basic body is exactly the parts that pass the two acceptances — a 4-DOF arm on a vertical lift with a magnetic tool-changer that swaps a wiper and a gripper, on an ESP32-CAM base. Every chore beyond it is a rung on an evolutionary ladder: each milestone bolts on one new printed or ordered part, and a task can't be attempted until the parts below it exist.

Acceptance ✓

M0 · Reach & Wipe

Arm · Z-lift · tool-changer · wiper/gripper. Clean a window; remote on the table. T1–T7

In sim ✓

M1 · Mobility

+ a mobile base. Now drives across the room, collision-free (T8, T11) — proven in sim below. Push & carry next.

Planned

M2 · Floor care

+ a floor squeegee + coverage. Sweep and mop a zone. T12–T14

Planned

M3 · Force

+ a torque wrist + base anchor. Open a drawer, a door. T15–T17

Planned

M4 · Payload

+ a carry deck + pour spout. Carry a tray, water a plant. T18–T20

Planned

M5 · Stairs

+ tri-star wheel clusters + a tail. Climb a flight, carry up. T21–T24

Dependency: M0 → M1 → {M2, M3, M4} → M5. 24 graded tasks double as the physical tests and the milestone steps.

Every line is under $10 and either off-the-shelf or home-printable — the project's budget rule, kept in the real world.

• Upgrade path: Feetech STS3215 bus servos (the SO-ARM100 / LeRobot lineage — encoder + position feedback) ~$14 each. Better control, but they break the < $10/part rule.
• Honest budgeting: the ≤ $100 cap is the simulation's per-run budget; M0 fits inside it ($78). The full stair-climbing carrier (M0→M5) is ≈ $172 — a real mobile robot needs motors and a battery, and we say so.

From a sim loop to a self-fabricating agent.

Phase 0 is done — and the simulation above already runs the whole need → design → fabricate → test → place loop end-to-end (the Phase 4 acceptance test, in sim). The rungs below are the path to doing it in the physical world.