Transition Action is the fledgling technical wing of Modal Path Ethics: a series about current technologies as they cross from research, prototype, or theory into reachable action. Each entry begins with a live technical event and asks what has changed in the field. This is not a futurist roundup.
Transition Action is a field inspection at the moment a capability starts to move.
The first recent headline is that the controller is losing its monopoly.
In March 2026, Nature Communications published a perspective on embodied physical computing in soft robots. The authors describe physical computing as a system where inputs are encoded into a mechanical kernel, processed through the interactions inside that kernel, and decoded as outputs. The paper surveys analog oscillators, physical reservoir computing, and physical algorithmic computing in soft robotic systems.
The important phrase is not “soft robot,” it is “computing kernel.”
In April 2026, another Nature Communications paper described a reprogrammable metamaterial robot that uses elastic wave metamaterials to perform analog and logic operations inside the robot’s physical structure. This robot does not just carry a computer. Its own mechanical form participates in the computation that steers its crawling behavior.
Then, in May 2026, a preprint on mechanical metamaterials and reservoir computing pushed the point further. The authors describe a metamaterial whose nonlinear dynamics process environmental vibrations with minimal digital computation. Its unit cells behave like physical activation functions. Its body separates incoming vibrations into useful frequency content. The structure itself becomes a neural substrate.
DARPA noticed the same transition from the institutional side. In April 2026, it issued a request for information on physical intelligence: materials and robotic structures that integrate sensing, computation, and actuation directly into the hardware, reducing dependence on centralized processors and continuous data movement.
Taken together, these are not scattered curiosities. This is a clear field signal:
Shape is already code.
Modern computing trained us to imagine a clean division.
In robotics, that division becomes another familiar split. The sensors gather data. The processor interprets it. The controller decides. The actuators move. Intelligence lives in the chip, while the body becomes a bundle of motors, wires, struts, joints, skins, and effectors waiting for orders.
That model works incredibly well for many machines. However, it also smuggles in a false metaphysics.
Bodies are never passive.
A leg filters the terrain before the controller receives anything. A joint constrains possible movement before any planning algorithm runs. A soft gripper solves part of the grasping problem by deforming around the object. A compliant tentacle does not need to calculate every surface detail before wrapping itself around an irregular shape. The material does some of the work.
Roboticists have known this for years under terms like morphological computation, embodied intelligence, and physical intelligence. What is changing now is the degree of explicitness. The field is no longer only saying that bodies simplify control. It is beginning to build bodies as computing systems.
When softness, stiffness, chirality, mass distribution, wave propagation, friction, buckling, deformation, or fluid flow can be arranged to transform an input into an output, form has crossed from object into program.
A rock can block a door. A ramp can redirect force. A spring can store energy.
These are all physical functions, but they are not yet computing systems in the stronger sense. The current physical-computing literature gets sharper by asking for encoding, kernel behavior, decoding, and programmability.
So the recent papers do not just show that bodies help machines move. We already knew that. They show physical structures actually being treated as programmable transformations.
The metamaterial reservoir computer is a clean example. Environmental vibrations enter the structure. The structure’s nonlinear unit cells transform those vibrations into richer internal dynamics. Sensors read the resulting state. A trained linear readout uses that state to perform tasks, including proprioception. The intelligence is distributed. The processor is still present, but the body has already done part of the transformation before the conventional computation begins.
The metamaterial robot is even more direct. Elastic waves propagate through a structured body. Mechanical layers perform operations inspired by Fourier optics. The output wave distribution changes how the robot crawls or steers. The robot’s movement is not only commanded by external control. It is generated through embodied mechanical computation.
The robot is not carrying code like cargo. The robot is code.
Klein begins from the pressure that shape can become executable.
That does not mean every shape is code. This means some shapes can be given the properties we normally demand from code: compositionality, readable intent, bounded behavior, reproducible execution, interface constraints, and verifiable effects.
The current physical-computing field already has pieces of this. It has kernels. It has encodings. It has inputs and outputs. It has reprogrammable transfer functions. It has mechanical logic. It has reservoir dynamics. It has bodies whose geometry contributes to classification, control, locomotion, and response.
What it lacks is a mature programming discipline.
A software function can be named, versioned, tested, imported, reviewed, sandboxed, fuzzed, linted, documented, and signed. But a shape that computes is harder to handle. Its behavior depends on material, fabrication tolerance, scale, temperature, wear, load, environment, and coupling to the rest of the system. The program is not only in the geometry as designed, it is in the geometry as realized in extant matter.
That is the very hard part.
A Klein-shaped language cannot treat physical computation as normal software with a sleek 3D interface. That would miss the entire transition. The point is not to make code look spatial. The point is to make spatial systems legible as code where they actually behave like code.
So, a Klein object needs more than coordinates. It needs declared sources and sinks. It needs gates, channels, constraints, and boundary conditions. It needs substrate capabilities. It needs a way to state whether a given behavior is logical, analog, probabilistic, fluidic, mechanical, thermal, optical, chemical, or biological. It needs conformance tests that can survive the gap between design and fabrication.
That is why shape-code needs verification earlier than normal software does. Once a structure exists physically, the program has already entered the world as an affordance. It can be pushed, struck, coupled, copied, scaled, misused, or embedded into other machines.
Shape-code is not at all made safer because it is physical. It is more legible only if we build the legibility layer first.
The old control model gives the central processor a throne. Sense, process, decide, act.
Physical intelligence collapses that sequence.
The controller does not vanish, but its role changes. It becomes a negotiator among distributed processes.
This is a much better model of real technical systems anyway.
A good biological hand does not wait for a central planner to micromanage every fiber. A good organism distributes control across nerves, tissue, reflex loops, morphology, fluids, and local constraints. Intelligence does not sit in one place issuing royal decrees to dumb matter. It spreads through the system according to what each substrate can do.
Robotics is rediscovering this under engineering pressure.
Physical intelligence squeezes in through these bottlenecks.
If a body can absorb, classify, constrain, or respond before central computation begins, the whole system gains speed and robustness. The loop shortens. The robot stops asking its processor to solve every local encounter from scratch.
This is the practical version of the philosophical claim. Shape is active participation.
The obvious mistake is to romanticize this.
Physical computation does not replace digital computation. The March Nature Communications perspective is careful about that. These systems remain proof-of-concept in many cases, and physical computers are unlikely to beat digital hardware in speed, density, and general-purpose flexibility in the near term.
The transition is not from silicon to matter. The transition is from centralized abstraction to substrate-aware composition.
Digital computation remains essential. The question is where the digital layer should stop doing work that the body, material, or environment can do better.
For Modal Path Ethics, this is exactly where the action-space changes.
A field does not become better because a new capability appears. It just becomes wider. Better paths and worse paths open together.
Physical intelligence could make robots safer, softer, more energy-efficient, more robust, more adaptive, and more usable in medicine, infrastructure, environmental repair, elder care, manufacturing, disaster response, and exploration.
It could also make systems harder to inspect. A conventional software controller can be audited in source form. A physical controller may require material testing, simulation, destructive inspection, sensor traces, provenance records, and behavioral certification. When intelligence is distributed into geometry and matter, responsibility can become foggier unless the field builds better instruments for reading it.
That is the governance problem hiding under the engineering headline:
The more computation moves into matter, the more our audit systems have to follow it there.
Klein sits quietly at this transition point.
Not as a claim that current metamaterial robots are secretly Klein already. They are not. These are research systems with their own methods, goals, and limitations.
But the field is now producing exactly the kind of object that normal programming languages are bad at describing: executable form.
A Klein-like layer would need to ask questions like these:
This is where “shape is code” becomes a discipline instead of a slogan.
A shape-code system needs something like types, interfaces, proofs, constraints, and manifests. It needs a distinction between design intent and realized behavior. It needs provenance from model to fabrication to calibration to deployment. It needs a way to say: this structure is supposed to compute by deformation, this one by wave propagation, this one by fluid routing, this one by buckling logic, this one by material response, and this one is only a passive support.
Without that layer, physical computing remains powerful but local. Individual labs can build remarkable devices, but the field struggles to generalize them. Each demonstration becomes a brilliant artifact rather than a portable unit of technical civilization.
With that layer, physical computing becomes composable.
The immediate reachability is modest and real.
The longer reachability is larger.
A future robot may not have a clean separation between body and program.
A future lab may print mechanisms with declared computational behavior.
A future engineering tool may not ask only whether a shape fits, holds, moves, or survives, but also what the shape computes.
A future safety regime may not certify only software and hardware as separate layers. It may certify executable matter as such.
This is not far-off science fiction. The pieces are already here in early form.
So, if shape is already code, then shape needs a programming language.
The official Transition Action is to build the legibility layer for executable form.
This means treating physical computing as a programming problem before it becomes an infrastructure problem.
Researchers should keep building embodied computers, metamaterial reservoirs, mechanical logic systems, and physically intelligent robots. That work is the engine of the transition. But the next layer has to make those systems readable beyond the original lab.
The field needs shared descriptions of physical kernels. It needs interface contracts for mechanical, fluidic, thermal, optical, and material computation. It needs conformance tests that compare intended behavior to realized behavior. It needs provenance from design file to fabricated artifact. It needs hybrid verification, where simulation, measurement, and declared limits are kept distinct instead of blurred into one confidence story.
The goal is to begin with the narrowest useful bridge: small, inspectable physical programs whose inputs, outputs, substrates, and constraints can be declared. A gate. A channel. A latch. A reservoir. A soft logic unit. A shape whose behavior can be tested against its claim.
The transition is already underway. Shape has begun to compute in public.
The next move is to make it legible before it becomes too useful to slow down.