Building the Missing Layer of Physical AI

Recurring Complexities, Intelligent Hardware, and the Next Chapter of the Maker Movement

I came to FAB26 partly as a co-founder of Bergsonne Labs and partly out of curiosity. Twenty-five years after Neil Gershenfeld and the MIT Center for Bits and Atoms launched the Fab Lab movement, the global community had returned to MIT to celebrate what had been built and, more importantly, to explore what comes next. The conference brought together researchers, educators, entrepreneurs, industrial practitioners and makers from around the world to reflect on how the discipline itself is evolving.

In many ways, attending FAB26 felt familiar. I grew up reading Cory Doctorow’s novels, where makers took apart devices, repurposed existing technologies and found ingenious ways to bend systems to new purposes. Those stories were about curiosity, openness and agency. They were rarely about building entirely new hardware platforms because that was never the point—and because hardware remained fundamentally difficult. Software invited experimentation. Electronics still demanded specialised knowledge, expensive mistakes and considerable patience.

Walking through the conference, I realised how thoroughly the maker movement has fulfilled its original promise of democratizing fabrication. Sophisticated manufacturing tools are now available in thousands of Fab Labs around the world. Designing and producing a mechanical object has become dramatically more accessible than it was even a decade ago. Artificial intelligence is beginning to reshape software development in much the same way, lowering barriers and accelerating iteration.

Yet over the course of the day, I kept noticing the same transition point. Every time a project moved from mechanics to intelligence, the pace changed. Building an enclosure, machining a component or printing a structure has become comparatively straightforward. Building the embedded system inside it remains considerably harder. That observation did not emerge from any single keynote. It emerged from listening to all of them together.

Neil Gershenfeld spoke about programmable matter and the continuing convergence of bits and atoms. Researchers in synthetic biology described the transition from modifying naturally occurring microbes to designing synthetic cells from first principles. Robotics researchers explored modular construction, programmable materials and distributed manufacturing. At first glance these seemed like unrelated research areas. The longer I listened, the more they appeared to be converging on the same engineering principle.

The synthetic biology session made this particularly explicit. One slide contrasted natural microbes with synthetic cells and summarised the transition in a single phrase: From tinkering to designing. The argument was not simply that biology needed better tools. It was that biology was becoming an engineering discipline built around reusable, purposeful building blocks rather than continuous adaptation of naturally evolved systems. It struck me that the same sentence could have served as the title of several other presentations that day. Construction offered a similar perspective through programmable materials, voxel-based structures and robotic assembly. Across disciplines, engineering knowledge was steadily being encapsulated into reusable abstractions.

Listening to these presentations, I realised they articulated the very question we had been pursuing at Bergsonne Labs. We started from a simple observation: software has become increasingly composable, digital fabrication increasingly programmable, yet embedded electronics still requires every team to solve much of the same engineering work from first principles. If the Fab Lab movement made manufacturing programmable, then Physical AI requires making embedded intelligence programmable as well. That is the missing layer.

The day before the conference, Jonathan Fiene and I spent nearly two hours sitting in MIT’s Hayden Library trying to answer what seemed like a deceptively simple question: What are the recurring complexities we are actually trying to abstract?

Our first answer sounded obvious. Electronics is complicated. But that quickly proved unsatisfactory. Complexity itself is not the problem. Every mature engineering discipline contains immense complexity. The more useful question is which engineering work every embedded project is forced to repeat, regardless of whether it is building a medical device, a robot, a wearable or an industrial sensor.

That conversation eventually produced a framework that describes how we think about embedded systems and what we do at Bergsonne Labs. By examining what is solved repeatedly in each project and what an abstraction layer should provide, we can look at this across four major categories of recurring complexity:

Design - System architecture, component selection, interfaces and electrical trade-offs - Validated functional building blocks

Fabrication - PCB implementation, manufacturing constraints, assembly and testing - Manufacturable hardware modules

Integration - Hardware, firmware, software, drivers and system validation - Standardized hardware–software interfaces

Continuity - Carrying a system from prototype into production without redesign - A common development platform spanning the product lifecycle

The first three describe recurring engineering work. Every embedded project begins by designing an electronic system, translating that design into manufacturable hardware and integrating hardware, firmware and software into a reliable whole. Although the details differ, the underlying engineering patterns are remarkably similar. Thousands of engineering teams repeatedly solve essentially the same classes of problems.

The fourth complexity is different. Continuity is not another engineering discipline. It is the consequence of the first three. Most hardware projects lose continuity somewhere between prototype and production. Development boards are replaced, electronics are redesigned, firmware is rewritten and manufacturing becomes a second engineering effort rather than a continuation of the first. Continuity therefore is not an isolated challenge; it is the symptom of recurring engineering work remaining trapped within individual projects instead of becoming reusable.

Bergsonne Labs is an attempt to build that missing abstraction layer. The Tiles themselves are the mechanism through which recurring engineering knowledge is packaged into reusable building blocks. Component selection, validated interfaces, firmware support, manufacturing constraints and mechanical integration become properties of the platform rather than decisions every engineering team must repeatedly revisit. The abstraction is therefore not the hardware itself. It is the engineering knowledge embedded within it.

The more I reflected on FAB26, the more I realised that this pattern extended far beyond embedded systems. Software has spent decades moving recurring engineering work behind increasingly powerful abstractions. Developers rarely think directly about compilers, operating systems or cloud infrastructure in the way they once did. Synthetic biology appears to be following the same trajectory. So do programmable materials and robotic construction. Every mature engineering discipline seems to advance by identifying recurring work, encapsulating it into abstractions and allowing future innovation to begin from a higher starting point.

Seen from that perspective, embedded intelligence is not simply another application area within Neil Gershenfeld’s vision. It is the unfinished chapter. The Fab Lab movement transformed how we fabricate physical objects. Physical AI requires an equivalent transformation in how we create the intelligence that lives inside them. The missing layer is not another fabrication technology. It is an abstraction layer for embedded systems.

That is why we are convening the inaugural Physical AI Summit on 17 September: https://www.physicalaiseries.com/. The ambition is to bring together the communities that are independently converging on the same transition. Intelligence is leaving the screen and becoming embedded in factories, medical devices, infrastructure, vehicles and everyday objects. That shift deserves a shared vocabulary, common architectural principles and a community capable of developing them together.

Looking back, that is what I took away from FAB26. The revolution that began twenty-five years ago is far from complete. The tools to fabricate almost anything now exist. The next challenge is making almost anything intelligent. If the first chapter of the Fab Lab movement was about democratizing fabrication, the next may be about democratizing embedded intelligence. The missing layer is beginning to come into view, and I suspect it will define the next twenty-five years as profoundly as digital fabrication defined the last.