LaunchedEditorial Listing

Prism by Navier AI

Navier AI (Navier AI Corp.) · Prism by Navier AI: Desktop Engineering Agent for CAD, FEA and CFD Simulation, Firmware and Reports

Open Prism by Navier AI

Prism is a desktop app for hardware engineers in which an AI agent turns a plain-language brief into parametric CAD, sets up and runs physics simulations (Navier's built-in Ferro FEA plus OpenFOAM, SU2, CalculiX, code_aster and other open-source solvers on your own machine), writes analysis scripts and embedded firmware, and writes the PDF report or slide deck. It suits mechanical, thermal, structural and aerospace engineers and small hardware teams who want to explore more design variants without scripting the CAD-mesh-solve-report chain by hand.

PricingPaid
Setupmedium
Runs onDesktop
Open sourceNo
DocsYes
CategoryCoding
Hardware EngineeringCADSimulationFEACFDMultiphysicsFirmwareElectronicsEngineering ReportsDesktop AppSubagentsAgent SkillsMCPPythonHuman-in-the-LoopGit WorktreesAutonomous Agent

Best for

Mechanical, thermal, structural and aerospace engineers and small hardware teams who already trust open-source solvers such as OpenFOAM and CalculiX and want an agent to handle geometry, case setup, post-processing and reporting so they can run far more design variants

Not ideal for

Teams whose design work lives in SolidWorks, CATIA, NX or Creo, organizations that cannot send engineering files to a cloud model provider or need fully offline work, engineers who need nonlinear or shell and beam structural analysis from the built-in solver, and hobbyists for whom $500 a seat a month is too much

Who it's for

Mechanical, thermal, structural, aerospace and electronics engineers, simulation analysts, and hardware startups and engineering teams that want to automate the CAD, simulation and reporting loop

Capabilities

  • Engineering agent that plans a task from a plain-language brief or attached requirements (a CSV, PDF spec or screenshot), then builds CAD, runs simulations, writes code and drafts the report, with optional review and approval at each step
  • Code-based CAD: the agent writes parametric build123d Python scripts on the Open CASCADE kernel, outputs STEP and mesh files, can design parts that bolt to imported CAD, and reads faces and bodies you select in the CAD viewer
  • Ferro, Navier's built-in structural FEM solver, compiled into the app with no install and no license server: linear static, modal, buckling and prestressed modal analysis of 3D solids, with matrix-free solves moving to the GPU on large models
  • Solver Desk: a local daemon (navier-solverd) that installs and runs OpenFOAM, SU2, Basilisk, code_aster, CalculiX, Elmer, Yade, Project Chrono, OpenModelica, Palace, openEMS and ngspice as containers, keeps solves running after Prism closes, and accepts a custom runtime catalog for your own solver builds
  • Bundled skills for design-to-CAD, FEA meshing, minimum-mass structural design studies, OpenFOAM conjugate heat transfer, marine CFD and sand casting, per-solver input formats, ArduPilot SITL and Navier's Stellarust block-diagram models
  • Results viewers for VTK-family outputs, CalculiX .frd files, ngspice rawfiles and Bode plots, plus a post-processing view with slices, clips and side-by-side comparison of runs
  • Coding for hardware: first-order sizing scripts, data reduction, test automation and embedded firmware, in a full editor and terminal, with a managed Python 3.12 environment (numpy, scipy, build123d, pandas, CoolProp, Cantera)
  • Engineering reports as PDF from Typst templates (structural, CFD, trade study, algorithm description, technical memo) and editable PowerPoint design-review decks
  • Native KiCad (.kicad_sch) and Altium (.SchDoc) schematic viewer, with parts and nets the agent can select and read; the Altium plugin can also read board stackups, tracks and design rules and run DRC
  • Four permission modes (Manual, Accept Edits, Plan, Bypass), a thread diff of every file change, git worktrees so parallel agent threads do not collide, and per-project memory notes
  • Sub-agents for large jobs, mid-task question cards, steering a running turn, scheduled prompts, and approvals answerable from another computer or a phone
  • Plugin catalog with Onshape, Altium Designer (beta), KiCad (beta), MATLAB and Simulink, GitHub, GitLab, Atlassian, Linear, Notion, Slack, Microsoft 365 and more, plus your own MCP servers and SKILL.md skills
  • Optional NavierAI Cloud runs (beta, enabled per organization) for solver jobs too large for your machine, with the command, machine and hourly rate approved before each job starts

Limitations

  • Costs $500 per seat per month; the free account's credit allowance is not published, and annual pricing is shown only in the app
  • The agent runs on Navier's backend: launching Prism requires an online sign-in, the agent does not work offline, and file content the agent reads is sent to the model as part of the conversation, even though solves run locally
  • CAD is generated as build123d Python scripts and STEP files; Onshape is the only CAD system with a documented plugin, and no SolidWorks, CATIA, NX, Creo or Fusion integration is listed
  • The open-source solvers run as containers and need Docker Desktop, Podman, Colima or an equivalent; gmsh is not bundled because of its GPL licence, though Prism can install it
  • Ferro is limited to linear analyses (static, modal, buckling, prestressed modal) on 3D solid meshes of a single element type; shell, beam and bar models are rejected, and inputs are strictly SI with no unit conversion, so a case in millimetres solves silently wrong
  • The docs say Prism provides no automated interference or DFM checks, even though the launch demo has the agent review a design for manufacturability
  • Not a sandbox: the agent runs with your user's permissions and can delete files through the shell within the workspace, and nothing in Prism undoes it
  • macOS builds are Apple Silicon only, and Windows and Linux builds are x86-64 only
  • The Altium Designer plugin is beta and Windows-only, the KiCad plugin is beta, and NavierAI Cloud runs are beta and must be enabled for your organization by Navier
  • Scheduled tasks run only while Prism is open
  • Newly launched (publicly available since November 3, 2026), and the founders' launch post says it will still make mistakes

Use cases

  • Turning a CSV of requirements into candidate designs for a drone cooling module, with parametric CAD, an OpenFOAM airflow and cooling check, a CalculiX modal analysis and a written report
  • Running a structural design study that iterates a parametric bracket to the lightest design that passes its static and modal margins
  • Pointing the agent at an existing OpenFOAM, SU2 or code_aster case directory to install the runtime, run it, debug a failed solve and plot the results
  • Comparing a batch of runs, such as cooling layouts or composite layups, in a run-explorer dashboard and summarizing them as a trade-study PDF
  • Writing data-reduction scripts for test data, or embedded firmware for a prototype, alongside the CAD and simulation files in one project
  • Reviewing a KiCad or Altium schematic or board with the agent before fabrication, checking nets, stackup and design rules

Our take

Prism takes the coding-agent pattern and gives it the tools a hardware engineer actually uses. Navier moved to this approach after its earlier physics-ML surrogates proved too narrow. The agent drives solvers engineers already trust, and leaves every mesh, input deck and script on disk where a reviewer can check it. The breadth is real: one window covers code-based CAD, linear FEA, CFD, electromagnetics, circuits and report writing, and skills and MCP let a team encode its own conventions. The limits are just as clear from Navier's own docs. CAD is generated in build123d rather than in the SolidWorks or CATIA files most mechanical teams work in. The built-in Ferro solver is linear, solid-only and unforgiving about units. The agent needs Navier's cloud backend even though solves stay local. And at $500 a seat a month it has to save real engineering hours. It fits best where a team already runs OpenFOAM or CalculiX by hand and wants to run far more variants. It is a weaker fit where the work is driven by a commercial CAD/CAE suite or must stay air-gapped.

Who should use it

Simulation-heavy hardware teams in aerospace, drones, marine, thermal management and industrial equipment that already rely on open-source solvers; engineers who spend their week on geometry clean-up, case setup and slide-making; and software-leaning founders who want to design and check physical parts without learning a commercial CAE suite.

Who should skip it

Teams standardized on SolidWorks, CATIA, NX or Creo with Ansys or Abaqus workflows; defense or regulated programs that cannot send design data to an external model provider; anyone needing nonlinear or shell-and-beam analysis from the built-in solver; and individuals who cannot justify $500 a month.

Strengths

  • Covers the whole loop in one app: geometry, meshing, structural, fluid, electromagnetic and circuit solvers, post-processing, code and reports
  • Runs established open-source solvers rather than learned approximations, so results can be checked the usual way
  • Every script, mesh, case file and result is a file in your project folder, with a git-based diff of every change the agent makes
  • Structural FEA works out of the box: Ferro is compiled into the app with no separate install or license server
  • Extensible with your own skills, MCP servers and solver builds, plus plugins for Onshape, Altium, KiCad, MATLAB and common team tools
  • Unusually candid documentation about what the agent and solvers cannot do

Weaknesses

  • $500 per seat per month puts it out of reach for casual use
  • Agent requires Navier's backend and sends the files it reads to the model, so it is not suitable for offline or air-gapped work
  • No documented integration with SolidWorks, CATIA, NX, Creo or Fusion; CAD is code-generated
  • Built-in Ferro solver is linear and solid-element only, with no unit conversion
  • Open-source solvers need a container engine on each workstation
  • Brand new, with several plugins and cloud runs still in beta

Prism by Navier AI pricing

Free account

$0

  • Free download for macOS, Windows and Linux
  • Sign in with a free Navier account
  • Limited credit allowance (size not published)

Prism

$500/seat/month

Billed monthly

  • Full desktop app: code, CAD, simulation and reports
  • Engineering agent with sub-agents
  • Integrated solvers and plugins
  • Durable harness that resumes long runs after a restart or dropped connection
  • Monthly LLM credits; extra usage credits can be bought

Forward deployed engineering

Custom

  • Navier engineers join your team, typically for three months
  • Prism deployed in your environment
  • Workflows built on your code, CAD and simulation
  • Engineers trained on live work

Simulation engagements

Custom

  • Navier engineers run the study in Prism
  • Fluids, structures, thermal and electromagnetics
  • Delivered as an inspectable report with the case files

Free tier limits: The download and Navier account are free and come with a limited credit allowance; Navier does not publish its size, and when credits run out Prism offers to subscribe or buy credits.

Note: Usage is metered per organization in tokens and cost, and higher reasoning-effort settings cost materially more. An annual plan is paid up front with credits refilling monthly; its price is shown only in the app. Admins can set a monthly spending limit per member. Purchased credits do not expire but are non-refundable. Engagements and forward-deployed engineering are scoped and priced per project.

Technical specs

Modalities

Text, Image

Available models

Claude Fable 5.1Claude Opus 5.5Claude Sonnet 5.5Claude Sonnet 5GPT-6DeepSeek V4.1 FlashKimi K3GLM 5.3 FlashXGrok 4.7

Where Prism by Navier AI excels

Concept-to-report design studies

Navier's launch demo went from a CSV of constraints to parametric CAD, an OpenFOAM cooling check, a CalculiX modal analysis, a manufacturability review and a written report, with every file kept for audit.

Running more variants of an existing open-source CFD or FEA workflow

Teams that already run OpenFOAM, SU2 or CalculiX by hand can have the agent install the runtimes, set up each variant and compare the runs, instead of rebuilding the setup for every change.

Lightweighting a structural part

The structural-design-study skill iterates a parametric part against Ferro static and modal results toward a minimum-mass design that passes its margins.

Electronics review before fabrication

Native KiCad and Altium schematic reading, plus the Altium plugin's access to stackups, tracks and design rules, lets the agent check nets and board rules alongside the mechanical work.

How Prism by Navier AI fits alongside other tools

Prism by Navier AI and Cursor

Cursor is an AI code editor for software repositories. Prism keeps a similar editor, terminal and diff, but its agent also builds CAD, meshes geometry, runs FEA, CFD and circuit solvers and writes engineering reports, so the two serve different parts of a hardware company's work.

Prism by Navier AI and Claude Code

Claude Code is a general coding agent you can point at simulation scripts or firmware. Prism, which can itself run Anthropic models, wraps the agent in engineering tooling: a CAD kernel and 3D viewer, a built-in FEA solver, containerized open-source solvers, results viewers and report templates.

Frequently asked questions

What is Prism by Navier AI?

Prism is a native desktop app from Navier AI for hardware engineering. It combines an AI agent, a code editor and terminal, a 3D viewport and a local solver runtime in one window. From a plain-language brief the agent can build parametric CAD, set up and run structural, fluid, thermal, multibody, electromagnetic and circuit simulations, write analysis scripts and firmware, and produce PDF reports or PowerPoint decks, with every file kept in your project folder.

How much does Prism cost?

Prism is one plan at $500 per seat per month, with the agent included. The download is free and you sign in with a free Navier account, which comes with a limited credit allowance whose size is not published. Paid plans include monthly LLM credits, and extra usage credits can be bought. An annual plan is offered in the app. Navier also sells simulation engagements and forward-deployed engineering, both priced per scope.

Which solvers does Prism support?

Ferro, Navier's own structural FEM solver, is built in. Twelve open-source solver families install from inside Prism and run as containers on your machine: OpenFOAM, SU2 and Basilisk for CFD, code_aster and CalculiX for structural FEA, Elmer for multiphysics, Yade for discrete elements, Project Chrono for multibody dynamics, OpenModelica, Palace and openEMS for electromagnetics, and ngspice for circuits. You can also point Prism at your own solver builds through a custom runtime catalog.

Which CAD and EDA tools and file formats does Prism work with?

The agent builds CAD as build123d Python scripts on the Open CASCADE kernel and exports STEP. Prism opens STEP, STL, OBJ, glTF and gmsh meshes, VTK-family results, CalculiX .frd output and ngspice rawfiles, and reads KiCad (.kicad_sch) and Altium (.SchDoc) schematics natively. Plugins connect Onshape, Altium Designer (beta, Windows only), KiCad (beta), and MATLAB and Simulink. No SolidWorks, CATIA, NX, Creo or Fusion plugin is listed.

Does Prism run locally, and are my files uploaded?

Your files stay on your disk and solves run locally: Ferro runs inside the app and the open-source solvers run as containers on your machine. The agent, however, runs against Navier's backend, so the content it reads to answer you is sent to the model as part of the conversation. Launching Prism requires an online sign-in, and the agent does not work offline. Optional NavierAI Cloud runs (beta) upload a case only when you approve the job.

Which AI models does Prism use?

You choose the model in the composer, and Settings controls which models appear. Prism's changelog lists Anthropic Claude models, OpenAI's GPT-6, DeepSeek V4.1 Flash (the default when the expanded picker shipped), Kimi K3, GLM 5.3 FlashX and Grok 4.7, and usage is metered per organization by tokens and cost.

Which operating systems does Prism run on?

macOS on Apple Silicon, Windows on x86-64 and Linux on x86-64. Intel Macs and ARM Windows or Linux machines are not supported. The open-source solvers also need a container engine such as Docker Desktop, Podman or Colima.

Prism vs Cursor or Claude Code: what is the difference?

Cursor and Claude Code are coding agents for software repositories. Prism uses a similar agent loop (plan, act with tools, review the diff) but ships with engineering tools: a CAD kernel and viewer, meshers, a built-in FEA solver, a container runtime for open-source physics solvers, results viewers and report templates. Hardware teams that also write a lot of software may use both.

Integrations & fit

OnshapeAltium DesignerKiCadMATLABSimulinkOpenFOAMSU2Basiliskcode_asterCalculiXElmerYadeProject ChronoOpenModelicaPalaceopenEMSngspicegmshArduPilotGitHubGitLabJiraConfluenceLinearmonday.comSmartsheetNotionOneDriveSharePointSlackOutlookMicrosoft TeamsGmailGoogle CalendarSentryLangSmithContext7DeepWikiRMFGMCPDockerPodmanColimaPowerPoint
Good fit forStartup / small team, Enterprise
Pricing modelPaid· Paid subscription required
See pricing on Prism by Navier AI →

About Prism by Navier AI

Navier AI, a San Francisco startup founded by former SpaceX engineers Cameron Flannery and Evan Kay, launched Prism publicly on November 3, 2026, pitching it as for hardware what coding agents have been for software. In concrete terms Prism is a native desktop application (macOS on Apple Silicon, Windows and Linux on x86-64) that puts an agent chat, a code editor and terminal, a 3D viewport and a local solver runtime in one window, attached to a project folder on your own disk. You describe the task, such as a part with its loads and constraints, a CSV of design requirements or an existing OpenFOAM case directory, and the agent plans and does the work with tools specific to engineering. It builds geometry as build123d Python scripts on the Open CASCADE kernel and exports STEP files you can open elsewhere. It meshes with Prism's own OCCT-based mesher (or gmsh, which Prism can install). Structural cases go to Ferro, Navier's in-house FEM solver, which is compiled into the app and handles linear static, modal, buckling and prestressed modal analysis of 3D solids, switching to the GPU on large models when one is available. Everything else runs through the Solver Desk: a local daemon installs twelve open-source solver families as containers and tracks every run. They cover CFD (OpenFOAM, SU2, Basilisk), structures (code_aster, CalculiX), multiphysics (Elmer), discrete elements (Yade), multibody dynamics (Project Chrono), Modelica (OpenModelica), electromagnetics (Palace, openEMS) and circuits (ngspice). Results open in Prism's VTU and post-processing viewers, and an engineering-reports skill writes structural, CFD, trade-study or memo reports to PDF from Typst templates, while a presentations skill builds editable PowerPoint review decks. The agent can split big jobs across sub-agents, ask you questions mid-task, and run on a schedule. Every script, mesh and solver input stays a file in the project folder, and in a git repository every edit appears in a thread diff. Plugins add Onshape (STEP export into the project), Altium Designer (beta, Windows only), KiCad (beta), MATLAB and Simulink, GitHub, GitLab, Jira and Confluence, Linear, Notion, Slack, Microsoft 365 and more, and you can add your own MCP servers or SKILL.md skills to encode team conventions. Prism also reads KiCad and Altium schematics natively. The tradeoffs are what an engineering buyer will care about. Solves run on your machine, but the agent itself runs against Navier's backend, so the files it reads are sent to the model provider, sign-in is required to launch, and the agent does not work offline. You pick the model, from Anthropic and OpenAI models to DeepSeek, Kimi, GLM and Grok. CAD is generated in code rather than driven inside SolidWorks, CATIA, NX or Creo, with Onshape the only CAD system that has a documented plugin. The open-source solvers need Docker, Podman or Colima. Ferro is linear only and strictly SI with no unit conversion, and the docs say plainly that the agent will solve a wrongly specified case without complaint. Price is $500 per seat per month after a free account with a starter credit allowance, so Prism is a professional tool, not a hobbyist one. Navier engineers also sell scoped simulation engagements and forward-deployed engineering, which typically runs about three months.

Updates from Prism by Navier AI

LaunchPrism launches publicly

Navier AI introduced Prism as its AI platform for hardware engineering, with downloads for macOS, Windows and Linux: an agent that builds CAD, runs physics solvers, writes code and firmware, and writes the engineering report, with every file kept in the project folder.

New FeatureSetup on demand and answers from any device (0.6.0)

Prism dropped the setup screen after sign-in: the agent now offers to install a container engine, gmsh or other local tools when a task needs one. Questions and approvals can be answered from another computer or a phone, and accounts that run out of credits can subscribe or buy credits from the chat.

New FeatureSchematic viewer and cloud jobs (0.5.9)

Prism began opening KiCad and Altium schematic sheets natively, and where Remote Compute is enabled the agent can run solver jobs on NavierAI Cloud machines after you approve each job's command, machine and hourly rate.

PricingAnnual plan (0.5.6)

Prism added yearly billing, with included credits still refilling every month, and a billing page showing seats and per-member usage.

IntegrationPlugin catalog and Onshape integration (0.5.0)

A redesigned Plugins page let users browse and install plugins from inside Prism, including Onshape document browsing and STEP export into the project, alongside a wider model picker.

Are you the founder? Claim this listing →