I went to Berkeley AI Hackathon 2026 with Justin and Angel, and I had a ton of fun.
Our team was called Plantcasso. The name is exactly as ridiculous as it sounds: a plant, a robot arm, and a paintbrush (ok more like a pencil), all wired together so the plant could make art. I worked mainly on the hardware side, which meant I spent a lot of the weekend touching wires, soldering, debugging servos, trying to make tiny plant signals readable, and learning once again that hardware will humble you at the worst possible time.
It was great.
The moment Plantcasso became real
The starting point was David Bowen’s Plant Machete, an artwork where plant signals were mapped into control signals for a robot arm holding a machete. We loved the idea of a plant directly controlling a kinetic sculpture, but we wanted to push it somewhere slightly different.
What if the plant’s expression did not disappear the moment the robot moved?
That question became the whole project. Instead of a plant moving a machete through space, Plantcasso would move a brush across a canvas. The plant’s electrical biosignals would become servo movements, and those movements would leave behind a physical artifact: a painting.
That made the project feel like both performance art and visual art. The arm moving is the performance. The painting is the memory of the performance.
What we built
Plantcasso maps a plant’s electric biosignals into servo control signals. Those signals drive a 3D printed robot arm, and the arm draws brushstrokes based on the plant’s hidden signs of life and agitation.
The fun part is that the same idea can be read in a few ways at once.
As art, Plantcasso is a way to let a plant perform. The plant is not just a subject sitting next to a machine. It becomes part of the control loop.
As a sensor platform, it hints at something more practical. Plant biosignals can respond to environmental stress, plant health, air quality, and other external changes. If those signals become unusual, the painting becomes chaotic. That gives you a visual representation of something the plant is experiencing.
We also liked the idea of the paintings acting as physical traces of randomness, somewhat like Cloudflare’s lava lamps. The exact signal path is messy, analog, biological, and environmental.
The four pieces
The project had four main parts.
First, we needed to read the plant. Plant electrical signals are weak and noisy, so this was the most important part of the whole system. We used conductive gel pads and an INA333 instrumentation amplifier to detect and boost voltage differences across the plant’s leaves and stem. Those readings went into an ESP32-S3 Super Mini.
Second, we built an unsupervised clustering model for anomaly detection. We collected plant readings, sampled sequences, extracted features, projected them into 3D space, and clustered them. The model was trained on a laptop, then the resulting weights were deployed to the ESP32-S3 for real-time inference.
One of the more useful features we found was Hjorth complexity, which gave us a better way to represent externally induced spikes. That became more important in the final clustering implementation.
Third, we built the arm. The robot arm was 3D printed and driven by five MG90 servos: base rotation, shoulder tilt, elbow tilt, wrist tilt, and wrist left/right. The plant signals were mapped into legal ranges of motion so that as the plant changed, the arm changed too.
Finally, we made a dashboard. The dashboard showed rolling information like detected voltage, spike count, Hjorth complexity, current cluster, and an agitation score. The ESP32 published serial data in a small structured format so the dashboard could visualize what the plant was doing in real time.
The dream version also has a water dispenser, fertilizer pellet dispenser, and a circular or scrolling easel so the arm always has fresh canvas. If the plant likes what it is producing, you could even imagine rewarding it with water or nutrients. That is very speculative, but it was fun to think about.
Hardware is where optimism goes to be tested
The hardest part was getting clean plant signals at all. Plant biosignals are infamously weak, and the hackathon environment was not exactly a quiet laboratory. We had laptops, cables, power supplies, people walking around, and a plant that did not particularly care about our deadline.
We had to attack the noise from multiple directions. Software filtering helped, but the hardware mattered just as much. We changed pad adhesion points, braided cables, and built physical isolation around the setup. Every little detail changed the signal.
Then came the servos.
I thought the plant signal processing would be the monster. It was not. The real nightmare was getting the PCA9685 servo controller to behave over I2C. Our best theory is that when multiple servos activated at once, the current draw caused brownouts. Servos are not polite little logic devices. They are hungry motors, and if the power supply or wiring cannot handle the surge, the voltage drops, the logic gets weird, and suddenly the board stops responding.
In retrospect, this was probably the most classic PCA9685 failure mode possible: trying to drive a bunch of servos from an insufficient power setup and then blaming I2C when the actual problem is power integrity. Sometimes it worked. Sometimes it did not. Sometimes it behaved just long enough to trick us into thinking we had fixed it.
By the end, our strategy was a mix of checks, redundancies, and crossing our fingers.
Also, mint plant stems are more fragile than expected. By the end of the hackathon, the plant’s stem was bent and the leaves were drooping. We had to give it a rest for the final presentation.
The demo worked
The best part is that Plantcasso worked.
It read signals from the plant. It reacted to agitation. The dashboard showed meaningful changes. The arm moved the way it was supposed to move. The painting was chaotic in exactly the way a plant-controlled robot painting should be chaotic.
For a project that started as “what if a plant could paint?” and had to become real over a hackathon weekend, that felt amazing.
I am especially proud that the abstract idea survived contact with reality. The clustering was clean enough to be useful, the arm looked alive, and the whole installation felt like the thing we imagined at the start. It was not perfect, mostly because the servo control interface still needs to be more reliable, but it was real.
What’s next
The next step is a better hardware rig and a broader dataset. Our proof of concept used mint, but the interesting version of Plantcasso should work across more plants and more environmental conditions.
There is also a lot more to explore on the art side. A scrolling canvas would let the plant keep painting indefinitely. Better brushes and a more stable arm would make the output more expressive. A water or fertilizer reward system would turn the installation into a strange feedback loop between plant, machine, and artist.
The code is here: github.com/Maltomatic/Plantcasso. The Devpost is here too: devpost.com/software/plantcasso-qhu2so.
Berkeley AI Hackathon 2026 was incredibly fun. I got to build hardware with friends, chase tiny plant signals through noise, met a ton of new friends, and watch a mint plant become a painter.
I would absolutely do it again.