Codex is built for software teams. Flux is built for hardware teams.
Flux runs the same frontier models, including OpenAI models, plus everything a hardware team needs: a team of AI engineers that works in parallel, learns your rules, and works in one live project with your engineers. Flux is model agnostic.
Flux is your team's autonomous hardware engineer. Give it a requirement. It plans the design, picks the parts, draws the schematic, routes the board, designs the mechanical parts, and writes the firmware. It checks its own work in simulation and design rule checks, and hands your engineers files ready to manufacture.
Codex is the coding agent from OpenAI. It is included in ChatGPT Free, Go, Plus, Pro, Business, Edu, and Enterprise plans.[1]
Codex works on coding tasks in the cloud, from bug investigations to new features. Each task has its own workspace. You review the changes and open a pull request when you are ready.[2]
Each Codex task runs in its own cloud workspace and continues while your computer is asleep.[2]
You inspect the changed files and test results, ask for follow-up changes, and open a pull request.[2]
Codex comes with eligible ChatGPT plans, on the web, on mobile, and in the desktop app.[2]
Codex can write scripts for hardware work. You then choose the outside tools, write the code that connects them, check the results, and keep it all working. This takes time and expertise, and every script is one more thing that can break. Each outside tool also needs its own license or account. For example, to connect to Fusion 360, you need a Fusion 360 license. Flux runs the same frontier models inside a complete hardware environment: a CAD and EDA editor, inspection tools, 734,000+ public parts with live distributor data, simulation, design rule checks, import of common CAD and EDA formats, manufacturing files, and one live project for the whole team. All of it is built in, tested, included in your Flux plan, and ready on the first prompt. Codex runs OpenAI models. Flux is model agnostic, so you are not locked to one model provider. Flux runs in your web browser. There is nothing to install, and your projects live in the cloud.
| Feature | Flux | Codex |
|---|---|---|
| What it is | AI hardware engineer with its own design tools | General AI coding agent[1] |
| Where it runs | In your web browser. Nothing to install. Your projects live in the cloud. | Tasks run in cloud workspaces. You use it from the web, the desktop app, mobile, or the command line.[2] |
| AI models | Frontier models from several providers, including Claude and OpenAI models | OpenAI models[1] |
| Schematic and parts | Built in. Picks from 734,000+ public parts. | Not built in. You connect outside tools and part data with scripts.[1] |
| Board layout and routing | Built in | Not built in. You connect an outside board tool with scripts.[1] |
| Mechanical CAD | Built in, kernel agnostic. From an enclosure to a complete robot arm. | Not built in. You connect an outside CAD kernel with scripts.[1] |
| Firmware | Writes firmware for the board it designed | Writes code, including firmware[2] |
| Simulation and design rule checks | SPICE, electromagnetic, thermal, and mechanical simulation, plus design rule checks | Not built in. You connect outside simulators with scripts.[1] |
| Manufacturing files | Gerber, ODB++, IPC-2581, bill of materials, pick-and-place, and more | Not built in. Your scripts or outside tools write the files.[1] |
| Tool licenses | Included in your Flux plan: the editor, mechanical CAD, parts data, simulation, and manufacturing files. Nothing else to buy. | Each outside tool needs its own license or account, for example a Fusion 360 license[5] |
| Team knowledge and rules | Written once for the whole organization. Every AI engineer applies it on every project, and Flux checks every design against your rules. | AGENTS.md files in each code repository[3] |
| Parallel work | A lead AI engineer splits a product into workstreams across projects, runs them at the same time, and reports back. Large changes wait for your approval. | Many coding tasks in the cloud at the same time[2] |
| Who reviews the work | The whole team, in one live project in the browser: electrical, layout, mechanical, and firmware engineers | Developers review the code changes[2] |
Orchestration
Hand Flux a complete product. The lead AI engineer splits it into workstreams, starts parallel threads across projects, manages them, and reports back.
Each workstream runs in its own agent thread. The main board, the daughterboards, and the enclosure come together at the same time.
The lead engineer starts work in other projects and tracks it all from one place.
It monitors every thread, steers work that goes off the brief, and collects the results.
Changes that move an interface or resize a board wait for your approval.
Flux writes a brief for each board with its outline, mounting holes, connectors, and the enclosure openings they line up with. Each board gets its own project and its own AI engineer, and all three are designed in parallel. Flux then places the finished boards in the main assembly and measures clearances and connector alignment in millimeters.
Built for teams
Flux runs in the browser, so everyone works in the same live project: engineers, reviewers, and AI agents side by side. No local CAD installation required.
Every design, revision, and comment lives in one cloud workspace your whole team can open.
Libraries, design rules, and past decisions stay with the team, so the AI starts every job informed.
Kick off agents, review their work, and pick up where a teammate left off.
Open a link and start working. No licenses to manage, no workstations to provision.
Speak to your AI engineer instead of typing, on your computer or your phone.
Customizable
Every team builds hardware its own way. Teach Flux your standards, connect it to your tools, and let it build the small apps each project needs.
Onboard Flux like a new engineer. Write your design guidelines, preferred parts, and lessons learned once, and every AI engineer in your organization applies them on every project.
Define your layout rules and manufacturer capabilities once. Flux checks every design against them, every time.
Connect any MCP server, or give Flux a key to any web API. Push firmware to your repository, read crash reports from devices in the field, or use the tools your team built itself.
Admins add API keys once for the whole organization. The AI engineer uses them but never sees them. Flux adds each key only to requests sent to the services you allow.
Ask for a one-off tool, and Flux builds it as a live page in the project: a power budget calculator that updates as parts change, a bring-up checklist that tracks progress, or a test report with charts.
Use Flux from Claude Code, Cursor, or any agent that supports MCP. Your agents can read and edit Flux projects and hand design jobs to the Flux AI engineer.
Connects to the services your team already uses.
Onshape 
Autodesk Fusion 
PTC Windchill 
Siemens Teamcenter 
Arena PLM 
OpenBOM 
Duro 
GitHub 
GitLab 
Memfault 
Golioth 
Particle 
Nordic nRF Cloud 
Edge Impulse 
NI SystemLink 
SimScale 
Octopart 
SiliconExpert Give Flux a requirement. The agent plans and does the design work on its own, in the cloud. The work continues when your laptop is closed, and your engineers review the result.
Every AI engineer works on its own cloud computer, with a desktop and a browser. It runs engineering tools, reads PDFs and spreadsheets, and writes its own scripts to check its work.
A coding agent can write its own scripts for schematics, simulation, and factory files. You then test and maintain them, and buy a license for each tool that they connect to. Flux has a CAD and EDA editor, inspection tools, simulation, imports, and manufacturing files built in, tested, and included in your plan. The agent goes straight to the design work.
An agent can write a simulator wrapper in an afternoon. It cannot write a library of 734,000+ public parts or live distributor data. Flux checks every part against its datasheet and live distributor data, and gets quotes from fabricators.
In software, you fix a bug and deploy again. In hardware, a wrong footprint or a missed check costs a new board order and weeks of waiting. Flux checks the design with simulation and design rules before your engineers review it.
Makes videos of the product it designed, for design reviews, customer updates, and launch pages.
You do not have to choose between Codex and Flux. Flux is model agnostic. It runs frontier models from several providers, including OpenAI models. Adaptive model selection gives each task to the model that does it best for the price. Frontier performance at 30% lower cost.
Work with the frontier models your team already trusts, inside Flux.
Every model gets Flux's specialized engineering tools, project context, and workflows.
When a better model ships, your team gets it without switching engineering platforms.
Avoid depending on any one model provider for your engineering capacity.
Adaptive matches each engineering step to the model that does it best, from deep design decisions to routine checks.
Flux picks parts from 734,000+ public parts in the Flux library and draws the schematic.
Flux places the parts and routes the board.
Flux designs the parts and assemblies around the board, from an enclosure to a complete robot arm.
Flux writes the firmware for the board it designed.
Verification lab
Flux doesn't stop at generating designs. The AI engineer simulates and checks its own work with professional-grade solvers, and it shows you the results.
SPICE simulation of analog, power, and mixed-signal circuits, run and read by the AI engineer.
Full-wave simulation of the routed board: impedance, S-parameters, crosstalk, and antennas.
Heat and airflow simulation of boards and enclosures before you build them.
Airflow and cooling through the enclosure, so vents, fans, and heat sinks work before the first prototype.
Finite-element stress analysis of brackets, enclosures, and mounts.
Electrical and manufacturing rule checks on every schematic and board.
Reads the datasheet of every part and checks the design against its pinouts, ratings, and limits.
Sourcing
Flux connects directly to major electronics and mechanical parts distributors. The AI engineer picks chips, connectors, screws, and standoffs that are in stock, compares prices across distributors, and replaces parts that are at end of life before the product goes to production.
Digi-Key 
LCSC 
Mouser 
Arrow 
Verical 
TME 
HQonline 
McMaster-Carr 
MISUMI 
JLCMC Manufacturing
Flux gets quotes directly from the fabricators for circuit boards and assembly, 3D printing in plastic and metal, CNC machining, sheet metal, laser cutting, injection molding, and casting. The AI engineer compares price and lead time, checks the design against each fabricator's rules, and keeps the quote current as the design changes.
JLCPCB 
PCBWay 
OSH Park 
AISLER 
Craftcloud JLC 3D printing PCBWay 3D printing 
Shapeways 
OSH Cut 
SendCutSend You do not have to choose. Codex connects to MCP servers, and Flux has one. Codex can read and edit Flux projects and hand design jobs to the Flux AI engineer. Your developers keep Codex for the software, and the hardware work goes to Flux.[4]
Flux runs frontier models from several providers. Adaptive model selection gives each task to the model that does it best for the price. Frontier performance at 30% lower cost.
Flux builds parts on OpenCascade and NVIDIA SMLib, and on Siemens Parasolid on request. The agent picks the kernel for each part.
$40/mo
billed annually ($50 monthly)
$80/mo
billed annually ($100 monthly)
$200/mo
billed annually ($250 monthly)
$4,900/yr
for 5 seats, billed annually ($500 monthly for 5 seats)
Explore, Build, and Pro start with a 14-day free trial. Cancel anytime. See all plans
Use Codex for software work in your code repositories. Use Flux when the result must be a board, mechanical parts, and firmware that are ready to manufacture.
Start with a free trial, or book a demo with our team.
