Compiled, not trained.
Yantra compiles control intelligence directly from human motion. There is no training run — no datasets ground through gradient descent, no reinforcement-learning rollouts, no GPU farm. We synthesise the controller in closed form and run it on the robot itself.
| Closed form | no gradients |
| Zero epochs | no rollouts |
| No datacentre | in the loop |
| On-device | at the edge |
Reverse Synthetic Neural Networks.
An RSN does what the name says: it runs the usual direction in reverse. Instead of starting from a blank network and searching for weights that fit data, it starts from the behaviour — human motion — and synthesises the control model that produces it.
Conventional learning is a search. You guess, measure the error, and nudge millions of parameters downhill, over and over, until the loss is small enough — an iterative, data-hungry, compute-hungry process with no closed-form answer.
RSN treats the same problem as one of synthesis. Given a target motion, it solves for the controller that generates it analytically — in one pass, in closed form. There is nothing to converge, so there is no training run to wait on and no cluster to rent.
A control model you derive — not one you discover by trial and error.
Motion in. Coordinated action out.
Three phases carry a capability from a human performance to a controller running on the robot. No phase involves a training loop — the same pipeline produces every primitive in the stack, a gait, a grasp, a gaze, and the cortex composes them into longer behaviour.
Human motion
We start from human performance — joint trajectories, contacts, weight-shift, timing. The motion of a person doing the task is the specification, not a label set to be fitted.
Closed-form synthesis
A Reverse Synthetic Neural Network solves for a control model directly from that motion — in closed form. No epochs, no gradient descent, no reinforcement-learning rollouts, no datacentre.
On-device control
The compiled controller is small by construction. It runs on the robot's own compute, inside the tight loop the actuators need — real time, with no cloud in the control path.
We don't grow a mind through a million corrections. We solve for it — once, in closed form.
| The usual wayTrained | Collect data, label it, run gradient descent for epochs on a GPU cluster, tune reward, repeat. Each behaviour is a separate training campaign — and a brittle one at the edges. |
| The Yantra wayCompiled | Capture the human doing it once, synthesise the controller in closed form, install it. The behaviour arrives already coordinated, and it carries the grace of its source. |
It carries the grace of its source.
A trained policy knows only the situations it was drilled on, and breaks at the edges. A compiled controller inherits the structure of human movement — so it transfers.
Inherited timing
Because the controller is solved from human motion rather than discovered by trial and error, it inherits the rhythm and grace of the source performance — the difference between a machine that lurches and one that moves like a person.
Across bodies
The same compiled skill transfers across chassis. A primitive solved from one performance is not welded to one set of limbs — it re-targets to bipeds, arms, and mobile platforms.
To the unseen
A compiled controller generalises beyond the exact motions captured. It interpolates and extends to nearby behaviours it never explicitly saw, rather than failing at the edge of its training set.
Intelligence that lives where the body is.
Embodied control cannot wait on a round-trip to a datacentre — the loop is too fast and a dropped link too costly. Because the models are compiled, not trained, they are small enough to run on the robot.
Compact by construction
Closed-form models are small — no billion-parameter network to host. They fit on low-power hardware a robot can actually carry.
Inside the loop
Inference runs at the cadence actuators demand. Latency you can stand next to, because the round-trip to a datacentre is gone.
No cloud dependency
The robot keeps its mind in a basement, a field, or a factory with no signal. Autonomy that doesn't borrow its intelligence from the network.
Deterministic to inspect
A synthesised controller is a defined model, not an opaque emergent policy — easier to reason about, bound, and verify before it moves a body.
Compiled skills, composed.
Each compiled controller is a primitive — a gait, a grasp, a gaze. The cortex stitches them into longer behaviour, and the library grows as new motions are synthesised. Generality is built up, capability by capability.
A single compiled skill is narrow by design. The reach comes from composition: a perception model, a balance controller, and a manipulation primitive coordinated by one cortex into work that none of them does alone.
As the catalogue of primitives widens and the cortex composes them more freely, the system covers more of the physical world — the path by which narrow, reliable capability accumulates into broad capability.
AGI-grade general intelligence is the north star, and we are honest that it is a research frontier. We walk toward it deliberately — each capability real, useful, and shipped — rather than declaring it solved.
The method, applied
See the method become systems.
Six systems carry a body from human motion to general intelligence — built on closed-form synthesis, and built to operate safely around people.