Inspiration

Most AI "design" demos stop at a mesh that looks right. In real maker work the failure is usually the handoff: CAD does not know motor torque, the BOM does not know PWM timing, and the firmware demo does not know whether contact force cracks the egg.

We wanted a personal studio where you describe a small home machine and get fabrication files only after the generated control code survives a real physics rehearsal. Pretty geometry was never the finish line.

What it does

STeLar is a browser app for home-scale mechanical and electromechanical ideas. No login, no user API key, no hardware.

You type something like a raw-egg gripper, a plant waterer, or a color sorter. The system:

Turns the request into a measurable functional spec
Sizes the mechanics with deterministic math
Designs CAD, picks real datasheet parts, and writes MicroPython
Reconciles those three domains when they disagree
Runs the literal firmware against MuJoCo contact / sensors on a virtual RP2040
Releases STEP, STL, GLB, BOM, firmware, telemetry, and a fabrication ZIP only if three gates pass

If the request cannot be proven with the supported physics profiles, intake rejects it instead of inventing a fake pass.

Live demo: https://stelar-build-week.vercel.app/

How we built it

Codex was the primary build agent for the orchestrator, CAD and firmware sandboxes, MuJoCo loop, SSE protocol, React/Three.js studio, tests, and deploy. GPT-5.6 is the runtime brain every live design still calls.

Model routing in the product:

Terra (gpt-5.6-terra): intake specs and the multi-agent room
Sol (gpt-5.6-sol, reasoning.effort: max): engineering math via Programmatic Tool Calling
Luna (gpt-5.6-luna): JSON/source repair and evidence-grounded Design Review

We used the Responses API end to end, not Chat Completions.

Programmatic Tool Calling. Sol does not eyeball torque in prose. It emits a hosted V8 program that must call schema-checked tools (get_material_inputs, get_actuator_inputs, get_geometry_inputs). We keep program and program_output under evidence/openai/.

Native multi-agent. Mechanical, Electronics, and Firmware run in parallel (multi_agent.enabled, OpenAI-Beta: responses_multi_agent=v1, background + poll). Systems Integration reconciles mismatches. On the egg gripper it replaced an unsafe population-mean force threshold with a weaker-shell operating limit. The unsafe draft peaks at 80 N and cracks; the corrected firmware peaks at 10.97 N, lifts 30.3 mm, and passes.

Explicit prompt caching. Material tables, component libraries, and stable system prompts sit behind prompt_cache_breakpoint and prompt_cache_options: {mode: explicit, ttl: 30m}. Cache counters are exposed at /backend/api/evidence/cache.

Stack: FastAPI + build123d (AST-audited) + MuJoCo + MicroPython virtual Pico on AWS Elastic Beanstalk; Next.js + React Three Fiber on Vercel. Downloads are gated on PTC margins, physics rehearsal, and firmware source hash == executed hash.

Challenges we ran into

Freeform LLM CAD often produced floating block piles, so supported families use parametric templates plus a connectivity gate, with agent CAD reserved for novel generic_device briefs.

Making multi-agent reconciliation real was harder than labeling four API calls as agents. The Systems Integration step only counts if it catches concrete pin, torque, power, or threshold mismatches.

Firmware-in-the-loop forced us to run the generated main.py unchanged. Virtual machine / utime had to advance MuJoCo time on sleep_ms, drive PWM, and feed ADC/I2C from contact physics.

Long Sol and multi-agent stages needed truthful SSE progress and persisted timings so the UI never looked stalled. We also had to keep unsupported requests as honest intake rejects.

Accomplishments that we're proud of

A full browser studio, not a chat dump: timeline, simulation scrubber, explore mode, BOM/files, Design Review, linked revisions
Three independent gates, including literal firmware identity on a virtual Pico
Failure-then-success egg evidence preserved in production runs
Real PTC and multi-agent traces on disk, plus visible explicit-cache counters
Judges can open a cold URL and inspect completed verified runs without setup

What we learned

GPT-5.6 is useful here when each tier has a job Terra cannot fake Sol's hosted math, and Sol cannot replace Systems Integration. Explicit caching matters once libraries and system prompts are large and stable. Verification only feels honest if the thing you download is the thing you simulated.

We also learned to scope physics tightly. Gripper contact, moisture pumping, optical sorting, and 1 to 2 axis motion are supported. Everything else should fail early.

What's next for STeLar

Broader verification families without pretending we do FEA. Better CAD quality on generic devices. Faster pipeline latency. Optional export packs aimed at printers and hobby assemblers, still behind the same gates.