# ⚡️ Building the AI Hardware Engineer with Matthias Wagner, Co-founder of Flux

Latent Space · 2025-11-22

<https://addtry.com/d215c3c6-5faf-4a65-a439-390741496831>

Matthias Wagner, CEO of Flux.ai, describes building the "AI hardware engineer" that turns product briefs into manufacturable PCB designs in under 30 minutes. After leaving Meta in 2019, Wagner built a browser-based collaborative CAD tool from scratch, designed as a reinforcement learning environment. The emergence of LLMs and reliable tool calling let Flux's agents search component libraries, check pricing and availability, and execute complex designs autonomously. In a live demo, Wagner designs a battery-powered Alexa-like device with ESP32, microphones, OLED display, and speaker in about 25 minutes. Flux now has 7,000 paying customers, growing 26x year over year, and Wagner envisions eventually letting users prompt full hardware products like smartphones into existence, claiming the cost of custom manufacturing is plummeting.

## Questions this episode answers

### How does Flux's AI agent autonomously design a PCB from a product brief?

Flux's AI agent can take a product brief and autonomously design a manufacturable PCB. In the demo, Matthias Wagner gave a voice assistant brief—ESP32, beamforming mics, OLED display, speaker, battery—and the agent searched through millions of components, selected parts, checked pricing and availability, and wired them. It took about 25 minutes (the average session length) to complete a schematic, though it still required manual addition of a low-power wake word coprocessor.

[17:09](https://addtry.com/d215c3c6-5faf-4a65-a439-390741496831?t=1029000)

### What inspired Matthias Wagner to start Flux?

While taking a summer off after leaving Meta in 2019 to work on Burning Man projects, Matthias Wagner rediscovered hardware design and was shocked that electronics design tools hadn't improved in decades, unlike software tooling. He saw the potential to use machine learning—inspired by Meta’s deep learning applications—to automate PCB design. That led him to co-found Flux in October 2019 to build smart design tools, which later evolved into the AI hardware engineer.

[0:46](https://addtry.com/d215c3c6-5faf-4a65-a439-390741496831?t=46000)

### How does Flux manage and iterate on its AI agent prompts?

Flux manages most of its prompts outside the Git repo in LangSmith, using tags for targeted deployments (e.g., to a single user or internal team). They pair LangSmith with LaunchDarkly for split testing. The team uses evals for deterministic tasks like finding a specific component, but relies on vibe checking for user experience factors like latency and verbosity. Domain experts can quickly edit prompts without a PR cycle, enabling rapid iteration on agent behavior.

[31:34](https://addtry.com/d215c3c6-5faf-4a65-a439-390741496831?t=1894000)

## Key moments

- **[0:00] Journey**
  - [0:03] Flux is building an AI hardware engineer to automate PCB design, says co-founder Matthias Wagner.
  - [0:19] Matthias Wagner's journey from childhood building to founding Flux was sparked by the stagnation of hardware design tools.
  - [0:46] Matthias Wagner's summer at Burning Man reignited his hardware passion and exposed the outdated design tools.
  - [1:49] Matthias Wagner's friend: "You're either gonna do something about it or stop talking about it."
  - [2:01] Flux was founded in October 2019 with a vision to use machine learning for automating PCB design.
  - [2:37] Flux built a browser-based CAD tool as a reinforcement learning environment; LLMs in 2022 then turbocharged the vision.
- **[4:04] LLM Inflection**
  - [4:28] Flux claims it was the first engineering design tool to ship AI chat, months before GPT-4's public release.
  - [5:29] Matthias Wagner says tool calling became reliable only around October 2023, unlocking complex AI agent actions in design.
  - [6:37] User expectations shifted in January 2024 to demanding a fully designed board from just a product brief, says Matthias Wagner.
  - [7:42] Flux shipped an agent in October 2024 that takes a product brief and autonomously designs a manufacturable PCB.
- **[7:47] Product Demo**
  - [9:55] Flux integrated with distributors like Digi-Key and Arrow to show real-time component pricing and stock levels.
  - [11:55] Flux's AI agent uses LangChain and LangGraph for function calling, not MCP, says Matthias Wagner.
  - [13:02] Flux designs its agent's personality to decide when to ask clarifying questions versus executing actions autonomously.
  - [13:17] Flux's component library contains over 1 million user-generated parts, managed like GitHub repositories for collaborative improvement.
  - [15:17] Flux's agent learns from user interactions and suggests personalized knowledge, creating a memory layer akin to Tesla's self-driving.
  - [15:59] Matthias Wagner: AI systems need memory for personalization, comparing Flux's knowledge base to Tesla's self-driving limitations.
- **[16:58] Alexa Design**
  - [17:09] Q: Can AI design a battery-powered voice assistant with beamforming mics, screen, and wake word inference?
  - [19:33] Flux's agent drafts a step-by-step implementation plan and asks clarifying questions before beginning the PCB design.
  - [22:06] Matthias Wagner: The agent's output quality heavily depends on how thoroughly the user specifies design requirements upfront.
- **[23:15] Agent Collaboration**
  - [27:46] Flux's agent autonomously selects an ESP32 microcontroller for the voice assistant due to its Wi-Fi, Bluetooth, and onboard antenna.
  - [30:24] JLC PCB can manufacture and assemble a Flux-designed board within 10 days for cheap, says Matthias Wagner.
- **[31:18] AI Engineering**
  - [31:34] Flux builds AI agents with vibe checks first, then adds evals like regression tests once the architecture stabilizes.
  - [34:35] Flux stores most prompts in LangSmith, not Git, to let electrical engineers quickly improve them without PRs.
  - [38:10] Flux uses LaunchDarkly for split testing prompts, but the integration overhead is high, says Matthias Wagner.
- **[40:49] Business Vision**
  - [41:16] Flux has 7,000 paying customers, 26x year-over-year growth, with Fortune 10 companies among adopters.
  - [43:05] Matthias Wagner predicts Flux will let users prompt hardware like smartphones into existence, ending traditional OEM manufacturing.
  - [44:00] Flux customers can cut total electronics cost to 1/100th by having AI design the PCB and only paying for materials.
- **[45:33] Demo Wrap**
  - [45:42] Agent finishes the voice assistant schematic but flags a missing wake word coprocessor and recommends manual layout steps.
  - [47:12] Flux is hiring software and hardware engineers to build the next generation of AI-driven CAD tools.

## Speakers

- **Matthias Wagner** (guest)

## Topics

Agent Platforms

## Mentioned

Anthropic (company), Figma (company), Flux (company), GitHub (company), Meta (company), Notion (company), Siemens (company), ChatGPT (product), Cursor (product), Devin (product), GPT-3 (product), GPT-4 (product), LangChain (product), LangGraph (product), LangSmith (product), Perplexity (product), Prompt Layer (product), Replit (product), VS Code (product), Windsurf (product)

## Transcript

### Journey

**Host** [0:03]
All right. We are in the remote studio with Matthias Wagner, CEO, co-founder of Flux.ai. Welcome.

**Matthias Wagner** [0:08]
Thank you. Great to be on the show.

**Host** [0:09]
So it says here on the website you are building the AI hardware engineer. Uh, what's your journey to building the AI hardware engineer? That's a, that's an unusual concept.

**Matthias Wagner** [0:19]
Oh, that's a great question. So look, I've always been a builder from childhood on, you know, Legos, wooden blocks, whatever. Um, I went to school for hardware software engineering back in Germany, worked at Siemens for many years afterwards.

Started like two hardware software companies out of that, and then fifteen years ago, moved to Silicon Valley. I was at, uh, Meta for a while, both on hardware software as a product manager and, uh, yeah, you know, I left Meta in early two thousand nineteen.

And, you know, I've also been going to Burning Man for a long time, and I decided, "Look, I'm gonna take the summer off. I'm gonna work on Burning Man projects," right? The whole summer long. And, and that's kinda how I got back into hardware after, like, lots of years being mostly in software.

And I had this realization that the tooling to make hardware had not improved in my lifetime. And that was so odd because the tooling to make software is, like, unrecognizable if you compare it to, like, mid-'90s or something like that, right?

**Host** [1:11]
Yeah.

**Matthias Wagner** [1:11]
It's, like, bonkers what we can do now. Um, and I was like, "Isn't that odd?" Right? Because the supply chain for hardware has changed as such that I can, as an individual now, get pretty much anything manufactured, right?

Why has the tooling not caught up with that capability, right? And I think, like, 3D printing was, like, an early trend here in this direction to, like, oh, you don't need injection molding. You can just 3D print this at home with, like, a thousand dollar 3D printer.

But that thing has had to be, like, slowly and gradually taking off. But in electronics specifically, nothing really has happened, and that, that was kinda weird, right? And so I kept complaining about that to friends all summer long, and eventually a good friend of mine said, "Matthias, look, you've been complaining about this all summer.

You're either gonna do something about it or stop talking about it." And I was like, "I could do something about this," right? And so then we started Flux in October two thousand nineteen. And I think the key insight here was, like, coming from Meta.

Like, at Meta, right, we were, like, far ahead, uh, lo- using deep learning and machine learning to power, like, anything you can imagine, right? And I had seen the power of that technology, right? And it was so obvious that there would be tons of use cases here to automate electronics design, PCB design, you know, with machine learning.

And I wasn't even thinking of LLMs at that point. And so we set out to build, like, a smart design tools is what we called it back then. I thought about calling it AI, but I didn't wanna sound like a lunatic.

And so-- But then, yeah. Right, look, you fast-forward, LLMs happened in '22, right? And then the, the whole thing really took off then, right? And it's just-- It was actually pretty good because, you know, if you're building, like, an AI code tool, like a Devon or Cursor or so, right, you can fork VS Code, right?

You can slap an LLM in, and, like, there's a lot of, like, infrastructure that you don't have to build, right? If, like, Cursor or Devon would have to build their own VS Code, that'd cost a hundred million dollars, you know?

Call me back in five years. So in our space, right, the opportunity didn't exist to just fork something like that because there was no open source design tool for electronics. Like, not a, not something good enough, at least.

Not in a browser, not written, you know, uh, with modern architecture. And so we spent the first couple years building that from scratch into the browser, kinda like a similar journey as, like, uh, Figma did, right? Um, and made that written collaborative and, and built that with in mind to use machine learning models, right?

Built the data structures right, the feedback loops. We always thought of the tool itself as the reinforcement learning environment, right? And we were just building the interface for users to provide us feedback and correct the agents. And then LLM comes along and then ba-boom, right?

That just turbocharged the whole thing. Um, and so yeah, the product today, right, you can, you can perfectly come in, design things manually, or you can have the agent design it for you, or you can collaborate. And I think this is, like, very similar, like in software engineering is most of the time you're doing this collaboration with the agent, right?

The agent does research for you or figures out some stuff, right, or runs some reviews and, um, and you can go back and forth until you have your, yeah, your manufacturable design out there.

**Host** [3:56]
Yeah. Amazing. I think I got in touch with you because of Lenny, which is he, which, uh, uh, who's, uh, one of your angels, I think.

### LLM Inflection

**Matthias Wagner** [4:04]
Yeah.

**Host** [4:04]
And so, like, what, what is the sort of really inflection points for you? I think you've been going sort of pre-LLMs for a while. Did you just plug in GPT-3 and, like, everything took off, or was there a more complicated engineering story behind that?

**Matthias Wagner** [4:17]
Yeah, it's a good question. So I think, I'm gonna claim here, I think we were the first engineering tool or design tool that had an AI chat in it. We shipped that, I think, a month or two months before GPT-4 became publicly available.

Um, and the, the realization we had is, like, that there's so much of the job in electronics design is information gathering, right? You have all these semiconductors. There's data sheets for them. Which one are we gonna use, right?

What are the exact specs? How do I configure that thing? And that, like, a, an agent here with RAG, right, would, like, supercharge the process, and you would don't, don't have to go to Google anymore. You can just ask the agent, right?

And that was, like, the first product we shipped, and that was... Yeah, I think that was maybe, like, February '22, if I'm getting that right, or '23. Something like that, right? And, and that was, like, magical, right, at the time.

What didn't work so good at the time is to-- we wanted then, of course, the agent to do things for you, to take actions. And if you remember, like, tool calling wasn't working that great in the early days.

I mean, they even thought of a ChatGPT that tried that early on, and it would consistently pick the wrong tool, right? And that wasn't really working. And I would say, like, that tool calling, I think, really only became reliable about a year ago.

Like, last October, November is when the, the models that shipped were ex- suddenly really good at calling tools. And I think that then changed everything, right? And you see that and then all these AI calling agents took off, you know, like, massively, uh, because suddenly you could use grep, right, uh, as a tool call effectively, right?

That was, like, a big unlock because before everybody was just, like, letting the LLM edit the, the freaking file, which was, like, very error-prone and slow. And then for us too, right, we were then able to hook in all these tools.

Like, suddenly you can have, like, a sub-agent that's hidden behind a tool to search the library, right, or, or figure out pricing and, and, and, uh, lead times for semiconductors, right? Suddenly you could have tools to essentially gather the context of the current project to, like, solve the current user request, right?

You could have suddenly tools to Add components to your project, remove them, wire them, run reviews, right, and all that kind of stuff. And so that was a big game changer. And I'd say that in the same time what we saw that there was a big shift in what users expected from an AI tool around January this year, I would say, where like suddenly...

Like before, users came to us be like, "Can you support this manufacturing process? Can you support like laser vias and stuff like that?" And then there was a sudden shift where suddenly everybody asked for, "Hey, I wanna come with a product brief and just get a fully designed board out of this.

I don't wanna do so much manual stuff here." Right? And that just overnight... And I think what is h- my hypothesis what happened I think in, in general in the world is that people changed what they expected from software from using all these other tools like Perplexity, ChatGPT, and so on, right, uh, Cursor.

Like an overnight shift where like, "No, if I'm gonna adopt a new piece of software to do something for me, it needs to take in a prompt with the problem and come with the solution back to me. I'm not interested in anything else."

And so that then led us to really like heavily invest in the, in the agent capability in Flux, right? And going from like a, "Hey, look, I can answer questions and perform single tasks," to like, "No, I can take a product brief, break that down into an actual execution plan, execute that plan, adapt as I go, and then come back to the user with a fully designed thing."

And then we sh- finally shipped that thing in early October, so like a month ago.

**Host** [7:47]
Amazing. Maybe we should show a little bit of the products, uh-

### Product Demo

**Matthias Wagner** [7:50]
Yeah

**Host** [7:50]
... so that people can get a little bit of a hands-on. For me, when I log in, I see brainstorm new project with AI, ESP32 robot controller, Raspberry Pi Pico, and Tesla vehicle display system.

**Matthias Wagner** [8:01]
Yeah. Yeah, you'll-

**Host** [8:02]
Nice

**Matthias Wagner** [8:02]
... you'll, you'll see here, when you see on my screen here, like you see all these like test projects I'm running here to debug things. But, um, you know, we have, we have some good examples here too. So maybe to start with, we've built a CAD tool, like an electronic CAD tool that's fully in the browser.

It's like real-time collaborative as a Google Doc or Figma is, right? We have like versioning in here, collaborative features, team functionality, all that good stuff, right? All these like basics. And then we have these agents in here, right?

And so, uh, the information architecture we have is very similar to GitHub, right? Um, where you can fork things. You can like, uh, uh, uh, uh, create branches, right, collaborate here, merge back in. I'm gonna just open here like a sample project.

Give this a second to load. And so then we have the full CAD tool here in the browser. So you have your, your schematic here, you know, for those who are familiar here with electronics. And then you also have the, um, the layout editor here, the mechanical editor.

And, and then you can go all the way here to, you know, visualize what the board's gonna look like. There you go. All right. So, and you can send this off from here to a manufacturer anywhere in the world.

**Host** [9:10]
Yeah, that's beautiful.

**Matthias Wagner** [9:10]
Typically China, and they'll, you know, in a week, 10 days, they'll send this back to you fully assembled.

**Host** [9:15]
Is that, is there, is that something I can do on your platform, or I have to export a file and send it by normal means?

**Matthias Wagner** [9:21]
That's a great question. So yeah, our goal is we wanna seamlessly integrate with manufacturers ultimately, but we haven't done this yet. You know, there is these like, uh... There's a couple different standardized file formats that you can give a manufacturer anywhere in the world, and they can manufacture the board for, uh, for you from that, and you can just export them from Flux.

The most popular one is called Gerber. I mean, the o- the other thing we have here, let me just rearrange some windows so I can see it. You, we have, you know, the, the full supply chain integrated, so we can look here what this board is gonna cost here for this component, you know?

**Host** [9:51]
Wow.

**Matthias Wagner** [9:52]
What's it gonna cost? Is it in stock? What are the lead times, right?

**Host** [9:54]
How do you know-

**Matthias Wagner** [9:55]
All this kind of stuff

**Host** [9:55]
... how do you know what the costs are?

**Matthias Wagner** [9:56]
So, you know, we've integrated with all the semiconductor distributors.

**Host** [10:01]
Okay.

**Matthias Wagner** [10:01]
You know? And we can look up what's in stock there, what will be the lead times. We can see here, Arrow here in this case, right, they have zero in stock of this component. Digi-Key has 234. What, uh, the price here at unit count of one, right, and all this good stuff.

And the cool thing is, right-

**Host** [10:17]
And doesn't it matter-

**Matthias Wagner** [10:17]
Yeah

**Host** [10:17]
... the, the volume? Because usually-

**Matthias Wagner** [10:19]
Yeah, yeah, the volume does matter

**Host** [10:20]
... you know.

**Matthias Wagner** [10:21]
So at, at, at volume one-

**Host** [10:23]
I see

**Matthias Wagner** [10:23]
... it's $2.64. At 10, it's $1.66. You know, like 48, you know, it's $1.25 and so on. Yeah, you have the, the price breaks in here. And so that's great, right, because the, the agent can query this too, right?

And then a component being on stock is absolutely critical if you wanna design and build something. If you think about legacy tools here, they don't have these integrations. They don't, they also don't have AI, for that matter. But, but it's easier as a result to design something.

And when you have a design with, say, 500 components, and one of them is not on stock or there's a lead time of 200 days, yeah, then the whole project has a lead time now of 200 days, right?

And so that's a huge problem, and that's something that the agents here also help in the tool, right? So for example, if we ask it, let's go back to schematic. This is IC1. So let's, we can ask here the agent.

This is one of the simpler tasks, right?

What would be a cheaper replacement for IC? There.

**Host** [11:29]
Mm.

**Matthias Wagner** [11:31]
Right? And so the agent can go now, look into the marketplace at all the distributors, right, find suitable alternatives, look at availability and pricing, right, then come back to us. And this is gonna take here 30, 60 seconds hopefully.

And it's like this would've taken us hours to do manually, right?

**Host** [11:49]
Yeah. Are you using MCP under the hood by any chance, or regular-

**Matthias Wagner** [11:52]
We don't use MCP, no

**Host** [11:55]
... function calling?

**Matthias Wagner** [11:55]
We... This is just all regular function calling, but we own the whole pipeline here, so I feel like MCP makes more sense if you wanna interface with third-party services, right?

**Host** [12:04]
Yeah.

**Matthias Wagner** [12:06]
But no, it's just, it's all function calling. You know, we use LangChain, LangGraph here under the hood. So of course it-

**Host** [12:11]
Okay

**Matthias Wagner** [12:11]
... answers with a counter question here. Let's do... Yeah, we want a drop-in replacement. So we have-

**Host** [12:16]
And was that a dec- By the way, can you zoom in on the, on this left, left side?

**Matthias Wagner** [12:19]
Yes, I can.

**Host** [12:19]
'Cause, uh, it's a bit hard to see. It's very small. Was that a decision to do a counter question? Is that part of the process or the model just came up with it?

**Matthias Wagner** [12:28]
Uh, that's a great question. No, we go back and forth of that. For like certain kind of requests, we want the model to default to action. So for example, right, if you're giving it an actual plan-

**Host** [12:39]
Yes

**Matthias Wagner** [12:39]
... to execute, we're really trying to like just jump into action, start working. If the user wants changes, they can just ask for that, right? But for other things like this one here, right, what it asks here is whether we want like a drop-in pin compatible substitute, right?

'Cause that would mean that we don't have to redesign this whole thing, right? And so that's like a critical question, you know, uh, for our search.

**Host** [13:02]
Yeah. Yeah.

**Matthias Wagner** [13:03]
But yeah, it's definitely something just like I would call this like personality design here or the personality UX of the agent is something we, we talk a lot about internally and iterate a lot about, right? So then you can see also what it does here, right?

So we have our own library for all these parts, over a million. That's all user generated. You know, it essentially does a tool call now where it runs a hybrid search against that, and in some cases it'll even like actually, uh, kick in an, an agent, like a plan execute agent here to be like, "Okay, look, here's this part we're looking for.

We're looking for alternatives to this that are pin compatible. Let's brainstorm the different vendors that could be offering this. Let's brainstorm the different search queries," right? And then we'll perform a bunch of searches, look at those, evaluate those, and eventually come back to us here with the, with this recommendation.

**Host** [13:50]
That's a very, very wide search space. Um-

**Matthias Wagner** [13:53]
Yeah. Yeah, it is, right. No, and the other thing it does is like, you know, sometimes the part might not be in our library, and so then it will do a web search, right, to find, uh, a suitable, um, you know, alternative that is in our library.

**Host** [14:08]
Is that... Again, do you use any third party tools or you made that yourself? Like Alexa is-

**Matthias Wagner** [14:13]
No

**Host** [14:13]
... it's very popular here in SF.

**Matthias Wagner** [14:15]
It's all our own stuff.

**Host** [14:17]
Web search.

**Matthias Wagner** [14:18]
For-

**Host** [14:18]
Wow

**Matthias Wagner** [14:19]
... we, we use for, for the, for the vector search we use Quadrant. Uh, semantic search is, uh, Algolia, right? And then we just fire them off in parallel and see what they come back with. We're gonna refuse the results then and re-rank them.

Um, like I said earlier, all the agent stuff, that's all LangGraph, LangChain. Trying to think of any other notable third party stuff we use. I mean, you know, OCR we also don't do ourselves. We use Azure for that.

So yeah, here it came back now, you know. Another cool thing is like, you know, we have-

**Host** [14:50]
Is that the right answer?

**Matthias Wagner** [14:51]
Yeah. Let's, let's look. Let's look, right? So it looked for pin compatible alternatives and so yeah, pin compatible you're only gonna find other ESP32s, right? But yeah, it offered to, to swap those, right? And this, yeah, this is the common dose of.

So let's ask it what the actual price for this is here. Um, where was I going? Oh yeah, the, the knowledge suggestions here, right? So another thing we've built ourselves is like, you know, an, an user driven knowledge base where like ask-

**Host** [15:17]
Okay

**Matthias Wagner** [15:17]
... agent learns things and let's see what I've learned here, right? It's like... right. What I've learned here is like that when replacing ESP32, you know, we want a drop-in pin compatible thing, right? And we can now accept that, we can edit that, we can reject that.

And what's really great about this is that it has enabled personalization on a user level, on a project level or organization level, and I think that's like critical now to AI systems. And like, you know, I have a...

If you ever use Tesla self-driving, right, it's magical, but you have a construction zone for two months in front of your house, it'll just not pick up, right, which lane to jump into and stuff like that, you know, because it doesn't have a person...

a real-time personalization layer in the brain.

**Host** [15:58]
It doesn't have memory.

**Matthias Wagner** [15:59]
Right. And that's a huge issue for these, for these systems I think. And so yeah, we built our own thing here, and what's really cool is, right, is like you have the ability to like centralize for your team to manage this knowledge, right?

The agent creates the suggestions themselves, and they're really good at picking this up, right? So yeah, that's a game changer. But we also found that we have then system level knowledge here that we train the system to do and that's really also how...

Like we, you know, we use mostly the off-the-shelf frontier, uh, LLMs here, and the way to like get them to behave the way we want them to behave is just with context engineering and injecting the right knowledge for the right kind of task they're doing, and that's incredibly effective, right?

That reduces hallucinations, that makes the model answer in a specific way over and over again, not just one in 10 times.

**Host** [16:51]
Okay. That's amazing. Uh, maybe I could ask for one more, um, sort of from scratch-

**Matthias Wagner** [16:57]
Yeah, yeah. Let's do that. Let's do that

**Host** [16:58]
... uh, projects just, just because I'm obviously a bit newer to this. But I've, I've actually tried to do this. I actually bought ESP32s and failed to do this. So my project is to make my own smart Alexa, right?

### Alexa Design

**Host** [17:09]
It-

**Matthias Wagner** [17:09]
Yeah.

**Host** [17:11]
It needs a, it needs a, you know, beamforming microphones, it needs like on device, uh, uh, wake word, um, you know, inference, and then it needs to be able to, to call, um, some API externally.

**Matthias Wagner** [17:25]
Mm-hmm.

**Host** [17:25]
And then it needs a screen. Um-

**Matthias Wagner** [17:27]
Yeah

**Host** [17:27]
... is, is that all within the requirements? I, I don't, I don't know about the screen part because you don't have a screen here.

**Matthias Wagner** [17:31]
Yeah, yeah. No, that, that's, that's, that's actually great. So why don't we use that, right? So, uh, I wanna build an Alexa type device with-

**Host** [17:40]
So like sp- let's say a speaker, microphone, screen, uh, and then some wake word inference. I don't know what else I need. Battery is nice to have. So the pow-

**Matthias Wagner** [17:53]
Needs to be-

**Host** [17:53]
... power draw is like a really interesting requirements

**Matthias Wagner** [17:56]
... battery powered and the battery should last a week.

Probably Wi-Fi enabled, right?

**Host** [18:07]
Oh, yeah.

Yeah, that's enough. You know, we don't, we don't need like too, too many, uh, requirements. Obviously, we could add things.

**Matthias Wagner** [18:15]
Yeah.

**Host** [18:15]
But I just wanna see like for the audience, like probably something they've thought about wanting and they don't have, how quickly can I make it a reality, right? I think that's the, that's the real problem with a lot of ...

software engineers who want to start with hardware that they can't really-- They don't know what they don't know.

**Matthias Wagner** [18:36]
Yeah, absolutely.

**Host** [18:36]
Which is exactly what I ran into. I bought the P-- uh, uh, ESP32 with, like, some dev kit things, and it's a bit slow, and it's... And then, and the firmware that was preloaded was, like, really bad. And then I was just stuck.

**Matthias Wagner** [18:50]
Yeah. It's, it's a little bit of a steep learning curve. I would say that, like, you know, AI makes that a lot simpler today, especially, like, you know, the debugging process, right?

As a novice, for example, there's like a thing that's like decoupling capacitors that you have to, like, set for, like, something ESP32, right? Otherwise, you know, it won't work or it won't boot, and this is kind of stuff, you know, that's like nobody points you at until you run into that issue.

And the AI agent's actually really great at being like, "Hey, look. I built this thing. It's not doing the thing. Why is it not doing the thing?" Right? And the agent will be great actually at helping to triage, you know, and finding these issues and teach you.

I came back here with a, with a plan. So let's look at this, right? I'll design a battery-powered Wi-Fi voice assistant with mic, speaker, and screen targeting one battery, uh, one week of battery life. I'll define the system.

Da, da, da, da, da, da, da. Under low acceleration loads, we're just to hit... Yeah. Oh, yeah, y- we didn't define how we're gonna charge this thing. USB-C charging. Fantastic, right?

Before the wake model, always listening, raise for record, or button to... Yeah. So that's, these are good questions, right? What wake model do you want? Always listening or a button?

**Host** [20:09]
Yeah, always listening.

**Matthias Wagner** [20:11]
Yeah, right. That's what I'm thinking too. And then, yeah, the screen size.

**Host** [20:15]
Yeah, OLED. Yeah, OLED. Just do OLED.

**Matthias Wagner** [20:17]
Like a small OLED is great. And then cell types.

**Host** [20:23]
I don't know.

**Matthias Wagner** [20:24]
Yeah, yeah. This is great. And we could ask this now, but I'm just gonna go with here the 18... This is a typical-

**Host** [20:30]
Yeah.

**Matthias Wagner** [20:30]
This is a typical lithium ion, uh, battery, uh, the 1865, uh, 65.

**Host** [20:35]
Yeah.

**Matthias Wagner** [20:36]
Let's go.

**Host** [20:36]
It would be-

**Matthias Wagner** [20:37]
And then-

**Host** [20:37]
It would be interesting is, like, if there was, like, sort of little help buttons on each term in case you needed to, like, do a side chat.

**Matthias Wagner** [20:45]
Yeah, for sure. You know, we have some of that, but you're totally right. It's like this one would've been a great candidate for it, you know?

**Host** [20:52]
Yeah, exactly. 'Cause you knew that for your previous context, but I did not know that. I would have to-

**Matthias Wagner** [20:56]
Yeah

**Host** [20:56]
... search. But if there was, like, a little "i" icon, I could just click on it, and, um, you know, then it would just tell me.

**Matthias Wagner** [21:02]
It's really interesting. You know, I was just, just last week I was sitting here with Devin thinking through, or maybe we could have like a, a right-click context menu here, right? Now it's gonna go do a Google search here in Chrome.

I'm not sure you can see that on the screen share. But, um, to just like, you know, ask a follow-up question based on this term, right? So I was just thinking in a similar vein, but I like this use case you have here.

Just like, yeah, there could also just be an "i" button, you know, and that just triggers like an, uh, a pop-up or so, you know, with an, uh-

**Host** [21:28]
Yeah

**Matthias Wagner** [21:29]
... AI summary or so what this thing is. I love that.

**Host** [21:31]
Well, in, in, uh, Windsurf we actually have this, like, uh, thing where you can click on any symbol, and it generates a deeper key for you. A deeper key is just kind of like a Wikipedia entry on it.

**Matthias Wagner** [21:40]
I know.

**Host** [21:40]
Yeah, right.

**Matthias Wagner** [21:40]
I just reinstalled Windsurf last week-

**Host** [21:42]
Oh, nice

**Matthias Wagner** [21:43]
... for that. Also, like, the, what do they call it, the Code Maps? They just-

**Host** [21:45]
Code Maps.

**Matthias Wagner** [21:46]
Yeah.

**Host** [21:46]
Yeah, that was the, uh-

**Matthias Wagner** [21:47]
Super cool

**Host** [21:47]
... I worked on that launch.

**Matthias Wagner** [21:49]
Awesome. Yeah, yeah, no, that's phenomenal. Now, we use Devin here religiously, and I think one of the most underrated features of Devin is the actual ask feature. 'Cause I-

**Host** [22:00]
Yeah. Ask Devin anything, yeah

**Matthias Wagner** [22:01]
... I use it even for my handwritten PR. So I'm like, "No, let's just talk about this a little bit first here," you know?

**Host** [22:05]
Yeah, yeah.

**Matthias Wagner** [22:06]
Um, 'cause I think that's also a thing here that I was gonna say is I think a lot of success here depends how well you flesh out what you wanna do, right? Like, if you just use this and ask it to, like, start here executing a plan, it's g- it's gonna be high variability in what you're gonna get back, right?

But the more we go through here and specify, the better this is gonna be, right? And y- you see that here, right? There's tons of more questions, right? All that interface, this or that, right? Speaker size, right? We're gonna ignore all this now.

Just tell it to just get going. We can actually look at the plan, the execution plan it's created here. Let me resize this. Right, so here's the goal of the project, implementation plan. You know, gotta do a schematic, gotta add all the components, gotta connect all the components, have to then validate the power architecture, and so on.

So we're just gonna tell it, "Let's go."

**Host** [22:57]
Let's go. So first of all, before you, before you, this call, I actually didn't even know you used Devin. But yes, I also work on Devin. So it's kind of cool to see this, uh, being used as well.

**Matthias Wagner** [23:08]
We love Devin here. Yeah, I mean, uh, and a lot here is inspired by Devin, like the knowledge base thing, right, is inspired by Devin, right?

**Host** [23:15]
Yeah, yeah, yeah. I was... It's, like, a very similar idea, so I was wondering, uh, you know, if you had any references there. And, and, you know, something that's interesting is, uh, the team has been working on computer use, uh-

### Agent Collaboration

**Matthias Wagner** [23:25]
Mm-hmm

**Host** [23:25]
... inside of Devin. And so you have... What you have basically is, like, kind of like a, a, you know, cursor or Devin for PCB and, like, hardware design, right? And it's a very complex, dense user interface. And so typically, uh, you know, Devin would not be able to, like, see this and navigate it.

But, uh, recently they added computer use into Devin, where it's got pixel precision on pressing buttons and typing in into the, the text field. And so I'm, I'm pretty excited.

**Matthias Wagner** [23:55]
I just hopped into the beta actually this morning. I've yet to try it.

**Host** [23:58]
Yeah.

**Matthias Wagner** [23:58]
But you're totally right.

**Host** [23:59]
Yeah, yeah.

**Matthias Wagner** [23:59]
So I'd say the previous version did pretty well navigating our interface. Where it struggles are these canvas interactions.

**Host** [24:05]
Yeah.

**Matthias Wagner** [24:06]
Right? Like sp- specifically, I don't think it's able to do dragging gestures, like mouse dragging gestures. This is an issue for, like, a canvas-based thing.

**Host** [24:14]
Uh, yeah, I, I mean, I think it's just a tool call. We can add that in. Um, I don't think it's-

**Matthias Wagner** [24:18]
I would love that. Tell the team please.

**Host** [24:19]
Uh, I know, I know exactly who to talk to-

**Matthias Wagner** [24:21]
I'll be, be willing to dog food that

**Host** [24:22]
... if it could happen. Yeah, yeah, yeah. Okay.

**Matthias Wagner** [24:24]
But yeah, I haven't tried to use comput- uh, computer, uh, for that use case yet. My hope was that maybe dragging is supported now. But yeah, I agree, right?

**Host** [24:33]
I-

**Matthias Wagner** [24:33]
I think especially for us also, like-

**Host** [24:34]
I doubt it. I don't think we, I don't think we tried it yet

**Matthias Wagner** [24:35]
... uh, uh, like a, a task I've done, Devin, a lot of work on is just export formats. But you need to test the exported file in some third-party software, and I have s- installed it on the VM for Devin, right?

But then Devin can't open that. It can only use the command line version of these tools, which is oftentimes limited, you know? So I'm really excited about Use Computer, even more excited about the, the Mac version that's, uh, in the pipeline.

'Cause, you know, again, our Canvas stuff has only relied on WebGL, and at least the previous implementation of the, the browser didn't have, uh, a GPU available, you know, which made the app super slow.

**Host** [25:16]
Okay. I mean, I'm sure these are things that the, the team wanna hear from you. Uh, yeah, you're talking to exactly the right person.

**Matthias Wagner** [25:24]
Yeah.

**Host** [25:24]
I can route you to-

**Matthias Wagner** [25:24]
No, I can keep on and on and on. We get, we'll be another two days, you know, with all the- ... uh, uh, all the things I'd like. But maybe here, back to what we're doing. So you see here, you know, it's chugging along.

It's finding now all the components we need for the project, but now here it's looking for the, an MCU that's Wi-Fi enabled and has a wake word coprocessor, right? 'Cause the way this works, right, especially with the battery-powered device, you wanna, wanna save power, and so you don't wanna leave the MCU running the whole time, right?

So simply how that's solved is that you have, like, a, a subprocessor here that stays on, that's low power consumption, that just listens for the wake word. But yeah, as soon as it finds critical components, it's, we're gonna see it.

It's gonna start placing this, right? And so you can watch here as it does the job, and we can talk to it and make corrections or changes, right, and give it feedback. Any questions you have while we're waiting here?

Yeah.

**Host** [26:15]
I mean, it's, it's really interesting because, like, obviously this is much more of a difficult problem, but I wonder what you could do with pre-visualization such that the center screen doesn't remain blank while you're doing this design phase.

Like, how can I use this time-

**Matthias Wagner** [26:32]
Yeah

**Host** [26:32]
... while the ch- the bot is thinking and creating to provide the next phase of input? I don't know how to do that.

**Matthias Wagner** [26:41]
We've been thinking about that too. I mean, a cool thing Replit does, at least for like a first user session when they sign up, is they use the canvas on the right side to show, to, like, market features of Replit.

You know, all the things you can do, right? And that works. And that, that's, that's like... I think for a first user session, that's great. That doesn't work so well, I think, for like, you know, somebody who's already onboarded.

Another thinking we have here, right, as these agents here we deliver become more reliable and capable, maybe by default we don't even show the canvas and everything on the right. We'll just show you this chat, you know, and off you go.

Um, another thought here is also, like, look, right now this agent is as slow as it'll ever be, right? I think here now with, you know, we'll, we'll be seeing the trend going also with, uh, the coding agents, you know, fine-tuning open source models.

They're, like, way faster as a result and more accurate. You can actually beat frontier models on quality that way. I think a lot here, uh, what's gonna happen in the next 6 to 12 months on our side is just, like, you know, having specialized...

Yeah, so it found, uh, an MCU here for us. Let's, we can look at this thing here. Yeah. Went for an ESP32. That thing is Wi-Fi enabled, has Bluetooth too, right? Has an onboard antenna, makes it really easy here.

We don't have to design our own an- antenna.

**Host** [28:04]
Why are all the hashtags in the description?

**Matthias Wagner** [28:06]
Oh, this is for search. Um, you can manually search here, and so that, that way you can, like, say, um, hashtag Wi-Fi, right? And you'll just find, you know, all, a lot of Wi-Fi related stuff.

**Host** [28:18]
Mm.

**Matthias Wagner** [28:18]
So it's just, you know, something users have adopted here.

**Host** [28:21]
Yeah. The renders are very, very pretty.

**Matthias Wagner** [28:24]
Thank you. Yeah. You know, a lot of this is also, like, you need to, like, see what it looks like.

**Host** [28:29]
Yeah.

**Matthias Wagner** [28:30]
Right? Like how, how big is this thing actually?

**Host** [28:32]
You get, you get a rough idea.

**Matthias Wagner** [28:32]
You know?

**Host** [28:33]
Yeah, you get a rough idea just based on this.

**Matthias Wagner** [28:35]
Yeah. If you click this, like-

**Host** [28:36]
Yeah, and I noticed that you have a bit of a social network, right? Like, uh, you have usernames, you have followers, and you have, like, the usage graphs and all that.

**Matthias Wagner** [28:44]
Yeah. Everything here is user generated, right? The whole library is user generated. Again, it's like the, the spirit of GitHub here.

**Host** [28:51]
Mm.

**Matthias Wagner** [28:52]
Why does everybody have to, like, maintain their own compression library, encryption library, right?

Extract emails from strings library. If we could just have this joint repository that is GitHub for code, you know, to, to c- compete on the best implementation of a given thing, but then also distribute that and have this feedback loop, right?

And so it's the same thing here, right? This representation of the ESP32, right? There's ergonomics to this. How good is the 3D model? Is the right data sheet linked, right? All this kind of stuff. Does it have the right part number?

And, uh, a- and so you want this, like, friendly competition here about building the best representation, the most ergonomic representation, right? And so that's why the, the user-driven approach here has a huge advantage. Plus, you know, if there's something missing, users can just add it.

They're not reliant on us.

**Host** [29:43]
What are we looking at here now?

**Matthias Wagner** [29:44]
Yeah, I was just gonna say. So it added, it's found an MCU with a wake word process- coprocessor, added that. Now it's looking for the audio path components, right? So the speaker, the amplifier, right? You can see it's looking for class D audio amplifier.

Oh, it seems like it's found one.

**Host** [30:00]
Yeah, this is a lot of autonomous thinking and searching.

**Matthias Wagner** [30:03]
Yeah. And so yeah, here's your, here's our speaker. This is our, this is our amplifier here, right, that I just added. Uh, and what's this? Oh, this is the microphone. It's an onboard microphone.

**Host** [30:15]
And typically, do you buy these parts separately and then there's a, a third party or middleman assembles them for you before shipping it?

**Matthias Wagner** [30:24]
Great question. So I mean, there is, like, there's literally tens thousands of manufacturers out in the world.

**Host** [30:30]
So it's like the She- the Shenzhen markets.

**Matthias Wagner** [30:32]
Yeah, yeah. Right. So totally. Right. So I think a popular option is in China is, is JLC PCB. And they'll take the design out of Flux, and they'll, they'll print the actual PCB board, right? And then they assemble it for you, and they send it back to you, right?

And that's a popular option because it's easy, it's cheap, it's fast. Like, within a week, 10 days, you have it back, right? And you can have 20, 50, 100, doesn't matter. But, you know, look, some people also they wanna solder it themselves for whatever reason, so they just get the, the board printed somewhere, order the components themselves from a distributor, uh, and then solder it themselves.

Yeah.

**Host** [31:08]
Well, I think you're, you're probably coming close to, to this project being done. Uh, I just wanna talk about the AI engineering here, right? Um-

**Matthias Wagner** [31:17]
Mm-hmm

**Host** [31:18]
... you use-- You said you use LangGraph, uh, LangChain. How do you, how do you iterate on your agent, right? Do you have evals? Do you have A/B tests? And, um, or do you, do you vibe check? What's the rough process?

### AI Engineering

**Matthias Wagner** [31:34]
All of that.

So, I mean, we got here essentially layer by layer, right? So we built first the, the cat tool essentially. Then we built like knowledge retrieval agents on top of that, right? Um, and then from there we went into tool calls and to be like more sophistic knowledge retrieval, and then we started having evals for these kind of things, right?

So these like foundational layer kind of stuff. And it's always a little bit of a mix of like evals and just vibe checking, right? 'Cause in the end, it's not enough for the evals to pass, right? What's the latency here?

Does the response... Is the response too verbose, right? Is-- Do I have all my links in here, right? What's the information presentation really that matters, right? And so that, that kind of stuff we do a lot with just vibe checking, just trying it over and over.

Um, but for things that are more deterministic, right, like, look, we need to find an ESP32 in the library, right? For that, we have evals, right, uh, that we run. And so but then on top of that then we then started building these agentic features.

First was, you know, it could perform single actions for you. It could add a component, remove a component, make a connection, right? And again, that for that we have evals to harden that. And then once we had that like working, we started building the actual like agent now, this long-running agent that we're looking at on top, right?

And for that agent, to be honest, it's mostly vibes right now. There's an increasing amount now of, of evals that we have, right? But I think how the V1 here was built or the V0 of that was built was all vibes, 'cause you're just moving faster.

I think the problem-

**Host** [33:11]
Yeah

**Matthias Wagner** [33:11]
... with evals oftentimes is like-

**Host** [33:12]
It's very common

**Matthias Wagner** [33:12]
... if you're early and you're still changing the architecture a lot, right, evals can get in the way. It's a little bit like unit tests sometimes, right? Or like regression tests. If you're like still iterating a lot and changing a lot, you know, it's easy for like re- uh, uh, uh-

**Host** [33:26]
It's too early

**Matthias Wagner** [33:27]
... like, yeah. Yeah, it's too early, right? But yeah, it's kinda like, you know, it is very similar in that sense to like regular code writing or like deterministic code, right? In that regression tests are nice, but there's all these typical issues with them.

They take a long time, they're flaky, and I think evals are, are, are very close to like what regression tests are. They take a long time to run, they're flaky, right? They need a lot of babysitting. One of the major challenges is surprisingly prompt management, call it.

**Host** [33:58]
Mm-hmm.

**Matthias Wagner** [33:59]
But there's so many like sub-agents here and sub-sub-agents. They all have their own little prompts, and managing that, and then also like even like we're getting to a stage where we wanna reuse blocks of prompts in other prompts.

And you can put this all in code, of course, right? As like text files into a, a Git repo. What we found is like that, you know, f-for our vertical, we have like domain experts on the team here that are electrical engineers, hardware engineers, and w-we need a, we need a way for them to easily improve these prompts, right?

And the turnaround of like committing, like opening a PR, landing that PR, it being deployed is just too long.

**Host** [34:42]
Okay.

**Matthias Wagner** [34:43]
So most of our prompts live outside of the Git repo.

**Host** [34:47]
Where?

**Matthias Wagner** [34:47]
In LangSmith, actually.

And we're pestering, you know, them over there to implement like a concept of blocks so that we can have more reusability, right?

**Host** [34:59]
What is a block?

**Matthias Wagner** [35:00]
Isn't it... If you, if you think about like a, a prompt and it's like, I don't know, 15 paragraphs, right?

**Host** [35:05]
I see. So sections of a block.

**Matthias Wagner** [35:07]
We-

**Host** [35:07]
Uh, sections of a prompt-

**Matthias Wagner** [35:08]
Yeah

**Host** [35:08]
... that are reusable. Got it. Got it. Got it. It's, it's interesting how like all these are, uh, generally reimplemented everywhere. Like, yeah, there's a lot of like Jinja templating. There's a lot of like just concatenate strings. There's different ways to concatenate strings, basically.

**Matthias Wagner** [35:23]
Yeah, yeah. We're, we're trying to find like the one way to rule them all. We also have a bunch of hard-coded strings in the, in the code, of course, right? Where like the-- we, we don't change them a lot.

It's fine. It just lives there hard-coded. Would it be nice to also be in LangSmith? Sure, but nobody has the time to migrate it, so whatever, right? But the ones that we work on a lot, they're all in LangSmith right now.

And, you know, there's, there's some great things about that. I mean, we love the sandbox there. We use it for tracing too, right? And it's nice to be able to like open a trace, go from there to the sandbox, make some changes to the prompt, rerun that, right?

I think that's, it's phenomenal, right? From a UX point of view for us here. But yeah, the, I guess the CMS for the prompts itself, you know, we've been poking them there, um, to invest more.

**Host** [36:08]
It's basically a CMS, right? Like it's, it's a very-

**Matthias Wagner** [36:10]
Yeah

**Host** [36:10]
... interesting form of CMS with like transfusion or like reuse and templating so that you don't, you don't, uh, mess up the formats and all that. Uh, I, I think it's an interesting problem. I, I would say that the prompts management startup category has not been that promising.

You know, I think there's like Prompt Layer that has been there. Humanloop got recently shut down. The company got, like, hired by Anthropic. Lang, uh, Smith has that. Braintrust has that. You know, it's just not super clear to me where...

In Cognition, in fact, uh, we have an internal one that was built ... basically the same time as Devin, the original Devin. They, uh, there's an internal playground that was, that was, uh, built that iterates on Devin's prompts.

So the pattern that you found with LangSmith, they independently invented two years ago for building Devin.

**Matthias Wagner** [37:03]
Yeah. And you have to, right? 'Cause it's all about iteration speed and being quickly able to test new things, right? In LangSmith we use the-- you can label your prompts, and we use that a lot to, like, deploy a prompt just for like a single user, right?

We like hacked our own system around that, right? But it's like, it's very obvious, right, that a better CMS is, is crucial, I think, right? But I also think the reason why these startups haven't done well so far is I, I don't think we understand the problem well enough yet to abstract a, a generalizable solution, right?

And I think that's where everybody is stuck, right? Even with LangSmith obviously there is like, you know, we use it. We've ne- found anything better, but it is so early. But I think it'll happen. Somebody will figure it out.

And I think you need to like, you need to connect this with the traces so that you can go like, you know, seamlessly back and forth, right? And you need to-

**Host** [37:56]
Yeah, it's, it's one seamless tool.

**Matthias Wagner** [37:58]
Yeah. And you need to connect it also to like split testing, right? So that you can deploy a change just internally, just to yourself, to fifty percent of the user base, right? These things all go, go together, I think, ultimately.

**Host** [38:10]
So you use LangSmith for all that. Do you have to bring anything else to handle this? Like split testing stuff.

**Matthias Wagner** [38:15]
Yeah, we use... For split testing, uh, we use here LaunchDarkly, and there's a lot of overhead to configure a split test for a prompt, as you can imagine, as a result. So it's not great. And then, yeah, we use tags.

Like I said, you can tag prompts in LangSmith, and then we have an internal system on, uh, uh, uh, on a syntax for these tags to say with this tag, this is like a, a user tag. We're only gonna deploy this prompt to this specific user, right, internally or just to everybody internally for us.

Or no, this is public now, right? This is the production tag. And so that's kind of like, you know, better than nothing, but it's not great, you know? Um, so yeah. I think this just goes to show there's, I think, a lot more here to, to be figured out before somebody, I think, can successfully build the, the, the prompt CMS to rule them all.

**Host** [39:03]
Yeah. Um, okay. Just checking back in on this agent.

**Matthias Wagner** [39:06]
Mm-hmm.

**Host** [39:07]
Um, how far... Is there like a progress bar on the show-- on the plan? Uh, if we-

**Matthias Wagner** [39:11]
There's no progress bar. We've been thinking about that. Um-

**Host** [39:15]
It's like an interesting problem of like you don't know... It's like a, it's like a, you know, stopping theory, right? Like when we have no idea how to predict when the agent will be done, but we have some idea of like how much of the plan have you completed, right?

**Matthias Wagner** [39:26]
Yeah. So I think the way we're thinking about is we haven't shipped or built anything here yet. But what we're thinking about is like you have here the, the plan, and we just wanna show what tasks here have been completed.

We can sort of like manually do this, right? It's still adding components. So we're very clearly here still in the, um, uh, to, to, to, to, to, in the, in the schematic development phase, right? Adding here the components, right?

Right now it's loading the, the power related stuff. So yeah, we're at step four here, right? Next would be USB.

**Host** [39:55]
Mm.

**Matthias Wagner** [39:56]
Then we will move over to con-connected components. So yeah. The, the average session is, I think, twenty-five minutes.

**Host** [40:04]
Wow.

**Matthias Wagner** [40:04]
Right?

**Host** [40:05]
Still, you're doing a lot of work.

**Matthias Wagner** [40:06]
Yeah. I mean, I think like from a complexity point of view, it's no different than writing software.

**Host** [40:11]
Yes.

**Matthias Wagner** [40:11]
The, the constraints are just different here. Like in software, essentially, you have like infinite characters available, and you can always just write the function instead of finding a library that does it, right? And here you can't do that.

You need to find the, these components, and they need to be compatible with each other, right? And they need, uh, each of these ICs needs supporting infrastructure, and you need to poke all this together. That's not to say that there isn't ways to make this faster, and we're working on that, right.

But yeah. The, right, the first goal is always to just to make it work and then, you know-

**Host** [40:41]
Yes, make it work

**Matthias Wagner** [40:41]
... then we figure out how to make it fast.

**Host** [40:42]
Make it fa-- Right. Make it fast. Yes. Yeah. So, so I think like the...

I mean, let's talk about like the, the sort of business side of things. What are the milestones that you've, that you've reached that you can share? And, and also like what, what is the, the, the grand vision, right?

### Business Vision

**Host** [41:01]
Like I think like one, one thing that is unclear to me is, you know, is this for hobbyists? Is there a broader like industry use case that, that you're going for? What is your sort of core audience that you're achieving?

**Matthias Wagner** [41:16]
Yeah, great question. So we have seven thousand paying customers today. That's like, you know, it's grown, it's like twenty-six x versus last year, right?

**Host** [41:26]
Wow.

**Matthias Wagner** [41:26]
So massive growth here. It's pretty crazy.

**Host** [41:28]
And all word of mouth, like... Yeah.

**Matthias Wagner** [41:30]
Yeah. So it's all organic, right? People find us on social media-

**Host** [41:34]
You have a very good video-

**Matthias Wagner** [41:35]
... learn about chat GPT complexity are big. Yeah.

**Host** [41:36]
On your YouTube.

**Matthias Wagner** [41:37]
You know.

**Host** [41:37]
Yeah.

**Matthias Wagner** [41:38]
The team here does great work on, on, on social media content and videos and tutorials and all that. Google Search is also a big source of users, right?

**Host** [41:46]
Is there like a, a big Reddit?

**Matthias Wagner** [41:48]
There's not a big Reddit, no. We-- I think none of us here are huge Reddit users. So as a result, you know, we're not big on Reddit. But, uh, but we have a community Slack that's pretty active. You know, we have a-- we hang out there too with users.

That's probably the main channel to, to interact with users today. And then, um, what was I gonna say? Yeah, so the f-- you know, most of users are self-serve. We have some enterprise customers already. You know, big Fortune ten, five companies, right, are starting to adopt it.

We have a lot of like, we, we have a lot of individual engineers at large companies. Like, you know, if you look on your desk, the brands you see there, we have like some of these fifty, sixty, you know, individual engineers using the product and are paying customers.

It's, it's very like similar to like Notion or Figma's go-to-market motion here, right? Uh, the product leads here hundred percent focused on improving the product, on getting, uh, uh, enabling users to get more value out of Flux, right?

And that's how we think about the go-to-market motion here. In terms of what's the ambition here, I mean, look, right, right now we're focused on PCB boards clearly, right? But I think ultimately the vision is like if you look at how you can prompt a poem into existence with ChatGPT, right, or a piece of code with Cursor, we want you to be able to prompt hardware into existence.

And not just the PCB boards ultimately, but the full thing, right? Like, why would you not be able to prompt a smartphone into existence, right? And if you can do that-

**Host** [43:14]
That's a lot of parts.

**Matthias Wagner** [43:17]
That's a lot of parts. Yeah, yeah, yeah. It's, that's, that would be 1,200 parts or so, right, for a smartphone.

**Host** [43:22]
For reference, this is how many what we're doing here? Is it 10?

**Matthias Wagner** [43:25]
Uh, this is probably gonna be like, when we're done here, probably like 50 or 60 or so.

**Host** [43:30]
Wow. Okay.

**Matthias Wagner** [43:32]
And so look, and if you can prompt something like a smartphone into existence, then why would you even still go to Amazon and spend two hours searching for a product if you can just describe what you want and get it made and sent to you within a week, right?

And I think the counterintuitive thing is that we've been all led to believe that to make things cheap, they have to be mass manufactured. And that used to be true in the past, but that's been changing, right, through automation.

And many of our customers now, right, the total cost of ownership now of their electronics or whatever they're doing is like one-hundredth of what it was before, right? Because if you can have an AI agent produce the design for you, then you're only paying material costs to manufacture it, and that's a fraction of what you pay for an off-the-shelf smartphone, an off-the-shelf Alexa device, you name it, right?

Now, of course, there are some categories that are, uh, uh, uh, they're gonna take a long time to get to. I think, like, doing something like an iPhone is, uh, is gonna take a long time simply because the iPhone enclosure is essentially a piece of jewelry.

Uh, so that's gonna take a while. But if you think about it, the majority of electronics, like, manufactured every day aren't iPhones. Not even close, right? Like, electronics are in everything you use, your headphones, your car keys, your charger, your microwave, your washing machine, your thermostat, your car, right?

I mean, it's just everywhere. And, and so there's a lot of low-hanging fruit here for us to come in and, and help these companies that make these, uh, uh, products, you know, uh, customize them more, make them cheaper, make them more capable.

And so we have a lot of like... We have, like, you know, vending machine manufacturers use Flux just 'cause electronics in vending machines, right? We have, like, uh, traffic light companies, 'cause guess what? Traffic lights, right? There's a computer in there, right?

We have farmers making their own farming and farm automation equipment with Flux, right? So, yeah, wherever you look where there's electronics and automation, right, we're, we're coming for that, you know? And I think this is the end for most categories of the OEM model ultimately.

### Demo Wrap

**Host** [45:33]
This, this thing looks like it, it might be, uh, taking a while, and, uh, uh, and, like, I do have to jump to the next thing. Um, oh, is it done? It's done.

**Matthias Wagner** [45:42]
Uh, yeah, the work's done.

**Host** [45:43]
All right. Then maybe we'll review it a little bit, and then, uh, we'll, uh-

**Matthias Wagner** [45:47]
Yeah, let's do it. Let's do it.

**Host** [45:47]
So how do you look at it? What, what do we do? What does the person do next? Yeah.

**Matthias Wagner** [45:51]
Yeah, exactly. Good question. So it's, it's looking good. It came back. So it says, you know, it's done here. Uh, and all the key components. It wired all the, the key components here. Oh yeah, it recorded some, some, uh, uh, estimates here on, on battery lifetime.

What is not done, the low power wake word component has not been added to this command. Okay, we need to go find that. There's some things it can't do that we have to do manually here, it told us.

And success criteria. Next-- So then recommended next steps, right? So yeah, we need to, like, do some research on the, uh, wake word coprocessor. And then, you know, go to the layout here, figure out the antenna stuff, and then we can use auto layout, you know, for placement and to run the ERC/DRC checks.

So that would be the next steps here, right? But we got pretty far here, right? We got all the components here. We can now go in here, like review this manually. We can make manual changes. So again, this is very similar to, like, you know, what the workflow looks like with Devon or Cursor, right?

The agent will get you to a, a given state, and so that either, uh, is done or needs feedback, and then you can take it from there.

**Host** [46:56]
But no, uh, I think overall super interesting and, like, I think, um, uh, you know, like y-you are realizing your vision of AI hardware engineer. I guess, like, the last thing is, uh, any call to action on, on both like the, you know, try us out side and the hiring side.

**Matthias Wagner** [47:12]
Yeah, absolutely. I mean, definitely come, right? If you're a hardware engineer or software engineer interested in hardware engineering, I think we'll, like, dramatically lower the barrier to entry and speed the process up. So definitely come check us out, provide feedback.

You know, this is, like, day one. There's a lot more work to be done, and we would love you, you know, to be part of this and help us out and direct us. On the hiring side, yeah, look, we're hiring.

We're hiring software engineers. We're hiring hardware engineers. We also have a bunch of, uh, go-to-market roles open we're hiring for. And I think we're looking for people who are, like, you know, excited about making hardware and democratizing hardware and excited about what, about AI here and really in-inventing what the, what the next generation of hardware design tooling looks like and the next generation of CAD tooling, what that looks like here with us.

And so it's exciting times, you know.

**Host** [47:57]
Well, a, a lot of... A, there's even ten interesting technical questions around the canvas that you're doing. It's, it's so, such an-

**Matthias Wagner** [48:03]
Yeah

**Host** [48:03]
... interesting, challenging problem.

**Matthias Wagner** [48:05]
Yeah, yeah. It's a whole can of worms on its own. The whole WebGL rendering, making it performant in any browser, on mobile browsers, memory usage. I mean, you know, there's no shortage of fun here as a, as an engineer.

**Host** [48:16]
Awesome. Um, well, thank you so much for your time, Matthias. I'm so glad to, to have, like, this, like, personal demo from you on Flux.

**Matthias Wagner** [48:23]
My pleasure.

**Host** [48:23]
It's-- This is a real problem that I've actually tried to solve on my own. Uh, and to see it solved live in like 20-something minutes is actually really compelling. Like, I think, like, you have a lot of confidence in your tool, uh, but also, like, you have a potentially unbounded problem of building hardware, right?

Of building the iPhone. So yes.

**Matthias Wagner** [48:39]
Obviously, there's an infinitely large market here, right? And it's just like a capability that people haven't had at scale up until this point. And I think that's what's exciting here.

**Host** [48:48]
Awesome. All right. Thanks, Matthias.

**Matthias Wagner** [48:50]
Thank you. Have a good one.

---

This library is powered by PodHood (https://podhood.com), the podcast website platform.
