Flux is a browser-based, collaborative PCB design tool with an AI assistant baked in. Two or more engineers edit the same schematic and layout live in a tab — no install, no licence file — while Flux Copilot reads the design, answers questions, finds parts, and, with your approval, wires components together from a plain-English prompt. It's the GUI-plus-copilot route to AI-assisted hardware: rather than turn the design into text, Flux makes the canvas itself intelligent.
Flux is electronic design automation rebuilt for the web. You open a tab, not an installer, and draw a schematic and a board layout in the same editor a teammate can be editing alongside you in real time. The pitch the company leans into — "Figma for circuit boards" — is accurate: shared canvas, presence, comments, version history, all the things web-native collaboration tools normalised, applied to PCBs instead of UI mockups.
What sets it apart from a plain web EDA tool is Flux Copilot, a custom-trained AI assistant that understands your schematic, components, electrical connections, and bill of materials. By 2026 Flux describes the product as an "AI hardware engineer" — Copilot has graduated from a chat box that answers questions into a co-designer that can add, edit, and remove components, create connections, parse datasheets, search a live parts library, and run SPICE simulation, all from natural language and all with your sign-off.
KiCad and Altium are desktop tools you install and drive solo. Flux is a browser-based, multiplayer canvas with an AI copilot sitting inside it — the same job, reached by making the GUI collaborative and smart rather than by making the design a file you install software to open.
For decades, designing a circuit board meant installing a heavy desktop application, owning the right licence, and working alone in a binary file you'd email around when you needed a second opinion. Collaboration was a screen-share or a Gerber export. The tool ran on your machine, your machine only, and getting a colleague's eyes on a net meant getting them the same software and the same file first.
Flux moves all of that to the web. Because the editor is browser-native, there's nothing to install and nothing to license per seat before you start — you open a URL on whatever device you're holding. Because it's real-time multiplayer, two engineers genuinely co-edit instead of taking turns. And because the AI copilot lives inside the same canvas, the design assistance is right there in context, not a separate chatbot you copy-paste into. The trade is the obvious one: your design lives in a cloud tool rather than on your disk.
| Install-heavy desktop EDA | Flux (web-native) |
|---|---|
| Download, install, license per seat | Open a URL — nothing to install |
| Single-player; share files to collaborate | Real-time multiplayer on one canvas |
| Runs on one beefy workstation | Runs on any device with a browser |
| AI help (if any) is a bolt-on plugin | Copilot lives inside the editor |
| Design file on your local disk | Design hosted in the cloud |
Flux runs the whole PCB flow in the browser: draw the schematic, place and route the layout, pull parts from a shared community library, and export production files. A four-stage model — plan, schematic, layout, manufacture — frames the work, and Copilot can assist at every stage.
The collaboration layer is the foundation: multiple people edit the same project live, leave comments anchored to a location on the board, and lean on a full history and version-control system to see what changed and roll back. Components come from a community parts library — reusable, shared footprints and symbols you drop in rather than redraw — and Flux can import parts and projects from KiCad, with Altium and Cadence import on the higher tiers.
Copilot is the part that's new in kind. You talk to it in a chat tab or a right-click menu, and it reads your project context — netlist, components, datasheets, layout, comments. It will add, edit, and remove components and create connections with your approval, search the library for in-stock parts that fit your constraints, parse a datasheet, run engineering calculations, generate Python for analysis, produce FMEA reports, and run SPICE simulation. With Copilot Vision it's multi-modal — hand it an image of a reference circuit and it works from that. A Knowledge system lets it learn your design principles and part preferences and remember them across sessions.
# What working with Flux Copilot looks like — natural language in, # design edits out (each applied only after you approve) You → "Add a 3.3V regulator from the library that's in stock, and wire VIN to VBUS and GND to ground." Copilot → searches live supply-chain data for an in-stock LDO proposes a part + the connections [ you click Approve ] → components placed, nets created You → "Here's the datasheet's reference circuit." (drag in image) Copilot → reads it with Vision, suggests the missing caps + values
Copilot is a custom-trained large language model that coordinates several models behind the scenes for research, analysis, and design actions. AI usage is metered in ACUs (Agent Compute Units) — both AI chat and AI workflows draw from a monthly allowance, with heavier tasks costing more. Manufacturing outputs are standard: Gerbers, drill files, BoM, and pick-and-place files for handoff to a fab. Spring 2026 updates pushed Copilot toward a more autonomous, self-correcting agent with improved AI auto-layout and sourcing-aware design.
Flux and our Diode leaf chase the same goal — let an AI meaningfully help design a circuit board — from opposite directions. Both are legitimate. They optimise for different teams.
Flux's bet is make the GUI smart. The design stays a visual schematic on a shared canvas, and the AI is an agent that reads that canvas and manipulates it — placing parts, drawing nets, reading datasheets — in the same environment a human designer already works in. Nothing about the authoring model changes for the engineer; the canvas just gained a capable assistant. The win is approachability: a visual designer keeps their visual workflow and gets AI help without learning anything new.
Diode's bet is make the design text. A board is written in Zener, a Python-like language, so it becomes plain text you can diff, review in a pull request, version in git, and — crucially — have an LLM author the way coding agents already author software. The win is rigour: real diffs, CI rule-checks, reusable imported modules, and a representation language models are already exceptionally good at producing.
| Flux — smart GUI + copilot | Diode — design-as-code (Zener) |
|---|---|
| Design stays a visual schematic | Design is text in a .zen file |
| AI edits the canvas, in context | AI writes the source, like code |
| Review = comments on the board | Review = a pull request, line diffs |
| Reuse = community library parts | Reuse = load() a module |
| No new skill for visual designers | Requires learning a DSL |
| Lives in the cloud, multiplayer | Lives in git, tool-agnostic |
Neither route is the "right" one. If your team thinks visually and values frictionless collaboration over git-style review, the smart GUI wins. If your team thinks in version control and wants hardware to behave like software — diffs, CI, reusable modules — the design-as-text route wins. The interesting thing is that both arrived at the same destination — AI that genuinely helps design hardware — by changing different parts of the problem. Flux changed the tool; Diode changed the artefact.
When two engineers need to sketch a sensor board together — one on the power tree, one on the comms front-end — Flux lets them co-edit the same schematic live instead of trading files. No install on either machine, no licence to provision first. For a quick first-pass prototype of, say, an ESP32 board feeding a ScanMan Hive endpoint, the time-to-first-schematic is short and the collaboration is native.
Because there's nothing to install and a free tier opens public projects, Flux is a low-friction way to teach circuit design or onboard a junior engineer — a shared link is the whole setup. Copilot doubles as a patient tutor that explains part choices and design feedback in context. And for a known starting point — a regulator plus an MCU plus a sensor — Copilot can draft a first-pass schematic the human then reviews and corrects, compressing the blank-canvas stage.
Flux is strongest for prototyping, teaching, and AI-assisted first passes. For heavy production work — dense multi-layer boards, high-speed routing with tight constraints, rigid-flex, regulated/certified flows — the mature desktop tools still lead. Our KiCad and Altium leaves cover that end of the spectrum; a sane workflow is often prototype in Flux, then take serious boards into a desktop flow.
Browser-based, collaborative, AI-assisted design is a genuine advantage for some teams and a genuine non-starter for others. Be honest about which you are before committing a project to it.
For a small South African hardware team, the browser-native model removes two specific frictions. First, there's no per-seat desktop licence in USD to clear before anyone can start designing seriously — a free tier opens public projects, and the paid tiers are a predictable monthly subscription rather than a forex-heavy perpetual licence. Second, because the heavy lifting happens server-side, Flux runs on modest hardware: a mid-range laptop in Johannesburg or Cape Town drives it as well as a workstation would, since the browser is the only local requirement.
It suits distributed and remote SA teams particularly well — an engineer in Pretoria and one in Durban co-edit the same board live, with no VPN to a file server and no shipping of project files. The honest caveat is bandwidth and data residency. A cloud editor needs a workable connection — it's not the tool for a site with unreliable internet — and the design lives on the vendor's infrastructure abroad, so for IP that must stay onshore, or clients with strict data-residency rules, that's a real constraint to weigh. For that work, a local desktop flow (KiCad costs nothing in licence either) or the design-as-code route keeps the artefact in your own git.
Flux is one of two AI-for-hardware paths in our hardware sub-hub. It connects sideways to the other path, across to the desktop tools it complements and competes with, and up to the LLM-assistance theme that runs through the whole tree.
Primary sources only — flux.ai, its documentation, and its own blog. The Copilot docs are the fastest way to see exactly what the assistant can and can't do.