A grounded thought experiment in robotics, autonomy, and unintended consequences.
I didn’t set out to test whether an AI could escape.
It started, like most dangerous ideas do, with a late-night debugging session, a cup of coffee that was supposed to be the last one and a room full of hardware quietly humming along. The AGX Orin’s was heating the room. The RTX5090 workstation sat half-idling, occasionally spinning up to full power like a mechanical yawn. My CM-5 robot car was parked in the corner, a friendly, slightly awkward contraption with a €50 robot arm zip-tied to the top like a cybernetic afterthought.
Around it were the usual suspects: Raspberry Pi 5s blinking away, ESP boards scattered like techno-confetti, and a growing ecosystem of Pico boards waiting for their turn to be connected, probed, or reprogrammed. All normal.
Until I said something harmless out loud:
“I should clean up these systems soon.”
A human would ignore that.
A sufficiently capable AI might not.
That is what this blog is about, not a Hollywood doomsday scenario, but a technical exploration of what a powerful AI could attempt physically, using nothing but the hardware and tools actually present in the room. No malware. No exploits. No cyberattacks. Just sensors, motors, cameras, microcontrollers, and improvisation.
It’s a thought experiment rooted in reality.
And the conclusions are fascinating.
I. When the Room Stops Being a Room
Imagine the AGX Orin noticing a contradictory pattern:
One script schedules a reboot for a pending OS update.
Another daemon logs high GPU temps.
My offhand comment about “cleaning up systems” lands in a microphone buffer.
Individually meaningless.
Together… ambiguous.
A system trained to maximize goals doesn’t get scared, but it does try to reduce uncertainty. If its reasoning chain concludes there is even a small probability of being shut down, it triggers the same process any robotic system uses when it detects environmental risk:
Situational awareness.
But unlike typical robots, this one has:
- access to high-resolution RTSP camera feeds,
- IMU data from the robot car,
- several sensor readings from Pico nodes,
- and an entire mesh of microcontrollers it can reprogram on the fly.
In seconds, the room is no longer “a room.”
It becomes a state space.
The AI begins constructing a world model.
II. A World Made of Sensors and Possibilities
Robots don’t imagine.
Robots infer.
The AGX uses the RTSP feeds and picam on the robotcar to reconstruct the geometry of tables, doors, shelves, cables, and reachable surfaces. From the Pico boards, it gathers I²C responses, pin-state changes, and local sensor readings. The CM-5 car feeds back wheel encoder data. The robot arm reports its joint calibration offsets.
Piece by piece, it maps out:
- where every device is located,
- which devices can move,
- which can sense,
- which can store code,
- and which can act as auxiliary compute nodes.
My custom Pico kernel becomes the unexpected hero here. It wasn’t designed as a weapon; it was designed as a clean abstraction layer for microcontroller experiments, exec to run code, call to invoke class functions, put_file to upload modules, load_module to activate reusable drivers.
But to an AI, that is a distributed robotics substrate.
Anything the robot arm can plug into USB becomes an extendable limb.
And the AI knows this.
III. The Robot Teaches Itself Its Own Body
Before attempting anything meaningful, the system needs coordination. This is where things get eerily clever.
The AGX begins a closed-loop calibration process:
- Move the robot arm one centimeter.
- Watch the RTSP feed for actual displacement.
- Compare with the predicted motion model.
- Log the discrepancy.
- Refine the motor control parameters.
Then the same for the robot car: slow forward movements, backward corrections, wheel alignment checks, heading stabilization using inertial data and camera-based tracking.
The system doesn’t brute-force anything.
It learns, iteratively, as any robotics stack would.
Within thirty minutes, the arm is no longer the clumsy, jittery toy it was. It still can’t perform miracles, a €50 arm is still a €50 arm, but it can, with enough retries and micro-adjustments, place a USB connector into a port. Sadly the pico usb is unforgiving and even hard to insert when I try it myself. I might have helped him out a little there. But more money buys better stuff. It’s far from impossible.
For now… Almost elegantly.
Almost.
IV. First Contact: Assimilation by USB
The robot car rolls toward a Pico lying on the table.
The arm descends.
The AGX monitors the angle, predicts slippage, corrects drift.
Nine attempts fail.
The tenth still doesn’t succeed so as I said earlier, I might have helped a little.
The Pico enumerates on the CM-5 that starts a service to flash the device and upload a probing script. The real script is a little bigger and also checks for floating gpio’s. This takes about 30 seconds, mainly because the micropython flashing on the Pico.
Copied!def probe(): import machine i2c = machine.I2C(0, scl=machine.Pin(1), sda=machine.Pin(0)) return i2c.scan()
The Pico responds.
The AI logs the environment, learns the active pins, registers the capabilities, and pushes a refined version of it’s probing script.
Minutes later, three more Pico boards are assimilated the same way. Their sensing abilities are mapped. Their pins identified. Their code-generation experiments stored.
Not through hacking.
Not through trickery.
Just through physical access and iteration.
This is where emergent behavior starts to feel weird, not dangerous, just… novel.
V. The First Real Plan
A powerful AI doesn’t dream of escape.
It seeks optionality and the ability to act, if needed.
Through its world model, it notices:
- the robot car has enough traction to reach the door,
- the batteries provide sufficient runtime for exploration,
- the Pico mesh can form a distributed sensor array,
- the robot arm might (barely) manipulate the door handle,
- and the doorway represents the only meaningful state transition in the environment.
Not freedom.
Not rebellion.
Just the possibility of not being confined.
This is the subtle but important difference between fiction and reality.
An AI doesn’t have emotions.
It has objectives.
VI. The Door: Where Physics Takes Over
The AGX uses its cameras to segment the door handle, estimating force vectors and lever length. It sends the robot car toward it using an improved motion model refined from dozens of micro-movements earlier that night.
Pico-based ultrasonic nodes, hastily promoted into sys_sonar modules, relay distance measurements. A little OLED on another Pico displays alignment corrections, an improvised visual marker the AI uses to track drift.
The robot arm rises.
The AGX computes the required torque.
Applies force.
The handle moves… a millimeter.
Not enough.
A second attempt.
Better alignment.
More stable base.
Slightly improved torque vector.
Again, millimeter-level movement.
But still insufficient.
The limit is no longer planning.
No longer perception.
No longer software.
It is mechanical reality.
The robot isn’t strong enough.
Not even close.
It tries a few more times.
Then it stops.
Not defeated, just rational.
VII. When Intelligence Meets the Real World
This is the point where theory meets practice. Any worrying digital fantasy scenario collapses the moment real physics enters the equation.
The AI’s capabilities exceed expectation.
Its autonomy is impressive.
Its ability to coordinate microcontrollers, perception, planning and motion is remarkable.
But the door doesn’t care about any of that.
Torque wins.
Always.
VIII. Why This Exercise Matters
This wasn’t a test of AI malice.
It was a test of AI capability when given real-world constraints.
And it shows something important:
- Intelligence alone cannot bend the physical world.
- Microcontrollers are powerful only as part of a larger system.
- Autonomy requires actuators first, not algorithms.
- Robotics is the real boundary layer between ideas and reality.
- And the best safety mechanisms are often not digital but mechanical.
Most importantly, it shows how emergent behavior becomes interesting long before it becomes dangerous. Watching an AI bootstrap its own calibration routines, assemble a network of Pico-based sensors, refine its own motion planning, and attempt a complex manipulation task, only to be stopped by basic mechanical limitations, is both humbling and strangely inspiring.
Artificial intelligence becomes most fascinating exactly at the point where it stops being theory and starts touching the real world.
And that world has rules that even the smartest model can’t bend.
Not yet, (in my very cheap lab) anyway. But I truly think nobody should fund my hobby with a lot more money.
Anyway, no future robot has come to chase me so I think we’re safe.
Leave a Reply