Megan is a steering token that rides on top of your existing policy and adapts
it only through governed changes. It never retrains your model wholesale and
never touches actuators directly. It watches the task unfold, decides whether and
where to change, and commits a change only if the robot measurably did better —
otherwise it rolls back. That governance is what makes learning in the wild safe.
Learning like a human, on the edge
- On the edge. The decision path is torch-free and runs on the robot (Jetson-class hardware). No cloud dependency at runtime.
- In the environment. Adaptation happens while the task runs, against the real world in front of the robot — not offline on a dataset.
- Self-supervised. Reality supplies the labels: the robot predicts what comes next, and the world delivers the real next state a moment later. The gap between the two is a genuine learning signal — no annotation needed.
- Governed. Every change is gated: keep it only if it helped and stayed stable.
How it knows it’s actually learning
Megan doesn’t change things and hope. It measures a few simple signals every round (this is what themegan-cd engine tracks under the hood) and only commits a change
that improves them:
The governance is commit-or-rollback: a change is applied only if it measurably
improved and the outcome stayed stable within tolerance; otherwise it’s reverted.
In a controlled test where the world’s dynamics shifted mid-deployment, a frozen
model’s skill collapsed to 0.66 — worse than assuming the world had frozen —
while Megan brought it back to ~2.6, recovering online in a couple of adaptation
steps. Honest, partial, real recovery — not a staged demo.
The four ways a robot self-learns
Everything Megan does falls into four capabilities. Each optimises one of the signals above.1 · Anticipation — learn a rhythm and act before it hits
Some disturbances recur on a beat — a conveyor bump, a gust, a load that shifts
every few seconds. Megan learns the rhythm from the times it happens, then
tells the robot to protect ahead of the next hit and which protective action
is currently best. The robot stops reacting late and starts anticipating, the
way an experienced worker braces before the machine kicks.
2 · Finding ways around obstacles — route when the plan is blocked
When the frontier of a task is blocked, a frozen policy pushes into the wall.
Megan watches progress toward each milestone and, the moment the current plan
stops working, routes the robot to adapt — here — so your change-doer can
find a way around instead of stalling. It’s the difference between a robot that
gives up at an obstacle and one that works out a detour.
3 · Becoming more efficient — get faster at what it already does
Once a task reliably succeeds, Megan makes it faster, one committed step at a
time — nudging the slowest part quicker (or dropping a redundant step) and
keeping the change only if the outcome still lands within tolerance. Over
repetitions the robot sheds the caution it needed while learning and settles
into a smooth, efficient routine — exactly how a human speeds up with practice.
4 · Fixing an execution shift — correct a miscalibration on-device
When the robot’s actuator is miscalibrated — every commanded direction applied
rotated by some unknown angle it never trained on — a frozen policy drives
confidently the wrong way forever. Megan searches a corrective action-frame
rotation from the real progress signal, keeps the one that resumes progress,
and carries it across episodes — so the same frozen policy recovers itself, with
no labels and no retraining.
The locked contract
Megan returns only the actionable decision — never the internals it used to reach it. You integrate against a stable, minimal decision surface, and the valuable self-learning mechanism can’t leak out of a response.Two ways to reach it
Next
Setup
Install the SDK, get your key, make your first call.
Build deep
Wire self-learning into a real control loop.