This comparison is published by Ionworks, the primary commercial sponsor of PyBaMM. We have aimed to represent both tools fairly based on public documentation, peer-reviewed literature, and direct product knowledge.
Both PyBaMM and Batemo are physics-based battery simulators: they describe what happens inside the cell rather than fitting an equivalent circuit to its terminals. Where they diverge is ownership. With PyBaMM, you build and own the model. With Batemo, the model is built for you and delivered as a validated, closed component.
Batemo is a Karlsruhe-based company founded in 2017 by Michael Schönleber and Jan Richter, with its cell modeling software reaching the market in 2018. Its pitch is precision: Batemo physically opens and characterizes a cell in its own lab, then delivers a parameterized, validated model that runs in seconds and is guaranteed to be the most accurate on the market. The model is positioned as neither a conventional equivalent-circuit model nor a finite-element model, but a proprietary formulation in between.
PyBaMM is open-source, Python-native, and focused on cell-level fidelity that your team controls. Its model library spans SPM through DFN, MSMR, composite electrodes, and sodium-ion chemistries, and every equation is readable. Ionworks adds a production-grade layer on top of PyBaMM, covering automated parameterization, reproducibility, data ingestion, and code export.
The choice between them is less about whether the physics is accurate and more about whether you want to own the modeling capability or buy validated models as a service.
What each tool is
PyBaMM
PyBaMM (Python Battery Mathematical Modelling) is a free, BSD-licensed simulation framework. Its architecture cleanly separates models, spatial discretization, and solvers, which means you can swap any of these independently.
The model library is broad: SPM, SPMe, DFN, MSMR, MPM, composite electrode models, and half-cell models. Chemistries include lithium-ion, lithium metal, sodium-ion, lead-acid, and more. Every model is readable Python. You can inspect equations, modify submodels, or add new physics without waiting on a vendor.
The community maintains PyBaMM independently. Ionworks is the primary commercial sponsor but does not control the open-source project.
Batemo
Batemo is a commercial battery modeling company whose products span from cell interior to pack. The core offering is the Batemo Cell Model: a physical, parameterized, validated model of a specific commercial cell, delivered for use in MATLAB/Simulink. Around it sits a product family: the Batemo Cell Explorer (a library of pre-modeled cells), Batemo Cell Designer (vary design parameters of an existing cell), the Batemo Cube Model (a discretized framework for local effects like temperature distribution), and the Batemo Pack Designer (cell to module and pack). In December 2025 the company launched Batemo Insights, described as a large collection of measured cell datasets.
The defining characteristic is that Batemo does the modeling. The company has opened and modeled over 100 cells of various formats and chemistries in its own lab. The model implementation is closed: you run and configure it, but you cannot inspect or modify the underlying equations.
Quick reference table
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| License | Open-source (BSD) | Commercial (per model / subscription) | Commercial |
| Model type | SPM, SPMe, DFN, MSMR, MPM, composite | Proprietary physics-based (closed) | SPM, SPMe, DFN, MSMR, MPM, composite |
| Model transparency | Full, readable, modifiable | Closed, configure and run | Full, built on PyBaMM |
| Who parameterizes | Your team | Batemo (lab service, per cell) | Your team, automated |
| Cell library | Reference parameter sets | Cell Explorer + Insights datasets | Bring/parameterize any cell |
| System integration | Via export (Simulink, MATLAB, C++) | Simulink blockset (cells Batemo modeled) | Simulink blocks from any PyBaMM model |
| Reproducibility | Depends on team infrastructure | Within delivered model | Immutable models, logged runs |
| Web GUI / AI interface | No | Desktop / MATLAB tooling | Yes — web GUI + AI chat interface |
| Primary use case | Cell R&D, parameterization, degradation | Validated models of commercial cells | Cell R&D with production-grade workflow |
| Cost | Free | Commercial, pricing on request | Contact for pricing |
Model transparency and ownership
PyBaMM
PyBaMM's DFN implements the full Doyle-Fuller-Newman equations. For cases where you don't need full spatial resolution across the electrode, SPM and SPMe run in milliseconds and are often sufficient for degradation mode analysis or rapid parameter sweeps. Composite electrode models handle graphite-silicon blends, MSMR captures multi-species intercalation thermodynamics, and MPM accounts for particle-size distributions.
The point is access. Every model is open, extensible in Python, and published with documentation and examples. If you need to modify a submodel, add a novel reaction mechanism, or implement a chemistry that doesn't exist yet, you do it yourself. The modeling capability lives inside your team.
Batemo
Batemo's model is physics-based and well-regarded for accuracy. The company backs its accuracy claim with a documented validation procedure and an explicit guarantee. For a team that wants a trustworthy model of a specific commercial cell and does not want to build modeling expertise internally, this is a strong proposition.
The limitation is that the model is a black box. The equations are proprietary and not exposed. If your work requires inspecting why the model behaves a certain way, modifying the physics, or extending it to a chemistry Batemo hasn't modeled, you depend on Batemo to do it. You are buying validated answers, not a modeling platform you control.
Key differentiators
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| Model access | Full source, modify any equation | Closed, run and configure | Full source, built on PyBaMM |
| Chemistry scope | Li-ion, Na-ion, lead-acid, custom | Li-ion (cells Batemo has modeled) | Li-ion, Na-ion, lead-acid, custom |
| Capability ownership | Lives in your team | Lives with the vendor | Lives in your team |
| Extending to new physics | Self-service in Python | Vendor-dependent | Self-service, built on PyBaMM |
Parameterization
PyBaMM
PyBaMM uses the BPX (Battery Parameter eXchange) format, an open standard JSON schema for battery parameters. Parameterization is programmatic: Python optimization routines handle fitting, sensitivity analysis, and train/test validation. Reference parameter sets like the LG M50 O'Regan 2022 set are available as starting points.
Ionworks automates fitting to OCV, rate capability, HPPC, and half-cell teardown data. Every parameter set carries provenance metadata, so you know which data it was fitted to, when, and by whom. The team builds and owns each validated model in-house.
Batemo
Batemo's parameterization is a service, and it is rigorous. Batemo physically opens the cell, runs an extensive characterization campaign in its own lab, and validates across the full current, temperature, and SOC range. The company has described per-cell parameterization as taking several weeks.
The trade-off is turnaround and dependency. If you need a cell modeled, you request it and wait for Batemo to characterize and deliver it. For a stable set of commercial cells, that is a fair exchange for guaranteed accuracy without lab work on your side. For a team iterating on its own prototype cells week to week, or fitting dozens of cells from in-house cycler data, an external per-cell service becomes a bottleneck.
Key differentiators
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| Who does the fitting | Your team | Batemo lab | Your team, automated |
| Turnaround for a new cell | Hours to days (self-service) | Several weeks (service) | Hours to days, automated optimization |
| Parameter format | BPX (open standard JSON) | Proprietary | BPX + structured provenance |
| Data pipeline integration | Manual | Batemo lab handles it | Yes, Maccor, Neware, BioLogic, Arbin |
The cell library
Batemo (key strength)
This is where Batemo is strongest. The Batemo Cell Explorer is a catalog of pre-modeled commercial cells across formats and chemistries, and Batemo Insights extends that with a large set of measured datasets covering electrical, thermal, and impedance behavior. For a team benchmarking commercial cells, or that needs a validated model of a specific cell on the market without running its own teardown, the library is a real shortcut. You pick a cell and start simulating.
PyBaMM
PyBaMM is not a commercial cell library. It ships reference parameter sets for a handful of well-characterized cells, and the community publishes more, but the expectation is that you parameterize the cells you care about from your own data. Ionworks makes that fast and repeatable, but it is a different model: build your own validated cells rather than buy them from a catalog.
For teams whose value is in their own cells (prototype chemistries, supplier-specific cells, internal designs), owning the parameterization is the point. For teams that mainly need accurate models of cells anyone can buy, a catalog is the faster path.
Key differentiators
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| Pre-modeled commercial cells | Reference sets only | Large catalog (Cell Explorer) | Parameterize any cell |
| Measured datasets | Community / literature | Batemo Insights (270+ datasets) | Ingest your own cycler data |
| Own prototype cells | Full support, self-service | Request as a service | Full support, automated |
Degradation modeling
PyBaMM
PyBaMM supports coupled degradation where multiple mechanisms run simultaneously and interact: SEI growth (including on particle cracks), lithium plating (including on composite electrodes), loss of active material, lithium inventory loss, particle cracking, porosity evolution, and electrolyte depletion.
The key word is "coupled." You can run SEI growth alongside lithium plating and LAM in a single simulation, with each mechanism affecting the others. Every degradation submodel is inspectable and modifiable, and published benchmarks exist for each mechanism.
Batemo
Batemo lists aging and lifetime as a core solution area and uses its validated cell models to study how cells degrade across operating conditions. For a team that wants a defensible lifetime answer on a specific commercial cell, the validated-model approach works well.
Mechanism-level model detail is proprietary. For teams doing research into the degradation mechanisms themselves, rather than predicting the lifetime of a known cell, the lack of model visibility is a constraint.
Key differentiators
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| Mechanism transparency | Explicit, inspectable, modifiable | Closed, detail not public | Explicit, built on PyBaMM |
| Coupled mechanisms | Yes, all run simultaneously | Not documented publicly | Yes, all PyBaMM mechanisms |
| Published benchmarks | Yes, peer-reviewed | Validation data on request | Yes, PyBaMM benchmarks apply |
| Primary use | Degradation research, mechanism analysis | Lifetime of a specific cell | Degradation R&D with structured workflow |
System-level integration
Simulink delivery is often assumed to be a Batemo-only advantage. It isn't. Both Batemo and Ionworks deliver cell models as Simulink blocks; the difference is which cells you can get a block for.
Batemo
Batemo cell models are delivered for MATLAB/Simulink, where they install as a blockset and drop into a larger system model. For teams whose system, BMS, or controls work already lives in Simulink, this is a clean fit: the validated cell model becomes a block in the existing environment with no export step. The constraint is that you get blocks for the cells Batemo has modeled and delivered to you.
Ionworks
Ionworks generates Simulink blocks from any PyBaMM model. Because you parameterize the cell in-house and Ionworks produces the Simulink (or MATLAB or C++) block from that model, any cell you can model is a cell you can drop into Simulink, including your own prototype and supplier-specific cells, not just a catalog of pre-modeled commercial cells. The block reflects the exact parameter set you validated, so the cell-level source of truth and the system-level block stay in sync.
PyBaMM
PyBaMM on its own has no native Simulink integration. Cell models need to be exported before they can participate in system-level simulation, which is the step Ionworks automates. Python co-simulation interfaces are also available for custom integrations.
Key differentiators
| PyBaMM | Batemo | Ionworks | |
|---|---|---|---|
| Simulink delivery | Via export (manual) | Blockset for cells Batemo modeled | Blocks from any PyBaMM model you build |
| Which cells get a block | Any, with export work | Catalog / commissioned cells | Any cell you parameterize, incl. prototypes |
| Pack-level modeling | Custom Python or export | Batemo Pack Designer | Custom or export |
| Standalone use | Yes, no ecosystem dependency | MATLAB/Simulink-centric | Yes, no ecosystem dependency |
Workflow and team access
Interface
PyBaMM requires Python fluency. For teams with strong programming skills, the startup cost is near zero (install via pip, run a notebook). For teams without Python experience, the learning curve is real.
Batemo delivers models into the MATLAB/Simulink environment. For teams already there, the interface is familiar and the cell model is just another block. The flip side is that you work with a validated black box rather than a model you can open up.
Ionworks has three ways in. Engineers who prefer code get a Python SDK and REST API. Team members who don't write Python get a browser-based GUI covering parameterization, simulation runs, and result review. And for teams moving toward AI-native workflows, Ionworks supports a chat interface where an AI agent selects, configures, and runs the underlying physics tools directly — so a question like "what happens to degradation if I charge at 2C instead of 1C?" becomes a parameterized simulation run without any manual configuration step. The physics doesn't change; the interface does. The platform has been built to be AI-operable and is already being driven through external AI coding tools by customers who integrate it into their own workflows.
Reproducibility
PyBaMM itself does not enforce reproducibility. If your team uses version control, virtual environments, and consistent parameter management, results will be reproducible. Many teams do this well. Many don't.
Batemo models are fixed, validated artifacts, so a given delivered model behaves consistently. Reproducibility across your own parameter variations and study setups, though, is on your team to manage.
Ionworks adds immutable parameterized models and logged simulation runs. Every run is recorded with its exact model version, parameter set, and input data. When a colleague asks "how did you get that result six months ago," the answer is one click away.
Licensing and cost
PyBaMM is free under a BSD license. No vendor dependency, no seat limits, no license negotiations.
Batemo is a commercial product, typically licensed per cell model or by subscription, with pricing available on request.
Ionworks adds the production-grade layer on top of free PyBaMM. Contact Ionworks for pricing.
When to use Batemo
Batemo is the right choice when:
- You need a validated, high-accuracy model of a specific commercial cell and don't want to build modeling expertise in-house
- The cells you care about are already in the Batemo Cell Explorer, or you're happy to commission them
- Your work lives in MATLAB/Simulink and you want a cell model that drops straight in
- Benchmarking commercial cells from a catalog of measured data is a recurring need
- You do not need to inspect, modify, or extend the electrochemical model itself
- Accuracy guarantees matter more than model ownership
Batemo's value is strongest when you want validated answers about cells you can buy, delivered as a finished product.
When to use PyBaMM
PyBaMM is the right choice when:
- Primary work is cell design, parameterization, or degradation analysis on your own cells
- Model transparency is required: you need to inspect, modify, or extend the electrochemical model
- You're iterating on prototype cells and need new models in days, not weeks
- Programmatic workflows are needed for parameter sweeps, optimization loops, or data pipelines
- Open-source licensing is a requirement or strong preference
- Multiple chemistries or novel model formulations are in scope
As Intercalation Station noted in February 2026: "PyBaMM is an excellent open-source battery simulator ideally suited for testing the latest physics-based battery models." That assessment, from Daniel Cogswell and Andrew Weng (Volta Battery Report contributors), captures the core value well.
When teams use both
A workable split: buy validated models of standardized commercial cells from Batemo where a catalog model fits, and build your own models in PyBaMM or Ionworks for prototype cells, novel chemistries, and any work that needs the physics opened up.
The risk to watch is divergence. If a commercial cell is modeled in Batemo and a closely related internal cell is modeled in PyBaMM, the two can drift apart in parameters and assumptions. Keeping a clear, reproducible cell-level source of truth, with provenance on every parameter set, is what stops two modeling tracks from quietly disagreeing.
Where Ionworks fits
Ionworks is built on PyBaMM by the team that created PyBaMM. It is the production-grade layer that addresses the gaps teams encounter when scaling PyBaMM across engineers, projects, and time.
Sections above cover the specifics. In short: Ionworks automates the parameterization workflow, ingests data from Maccor, Neware, BioLogic, and Arbin cyclers directly, makes reproducibility the default rather than the aspiration, and generates Simulink blocks (along with MATLAB and C++ code) from any PyBaMM model. That last point matters against Batemo specifically: Simulink delivery is not a service you wait on for each cell, it's something you produce yourself for any cell you parameterize, including prototypes.
On interface: Ionworks supports three access modes. A Python SDK and REST API for engineers who want programmatic control. A web GUI for team members who don't write Python. And an AI-native chat interface where an agent drives the underlying simulation tools directly — the same parameterization, model training, and simulation runs, but triggered by a question rather than a configuration screen. Teams already using external AI tools like Claude Code or Cursor to drive technical workflows can integrate Ionworks the same way. The physics is unchanged; the interface adapts to how your team actually works.
The result is the accuracy of a physics-based model with the difference that the capability, and every parameter set, stays inside your team.
Ionworks is SOC2 compliant, headquartered in Pittsburgh, and was founded in 2023.
For teams weighing a validated-model service against owning the modeling in-house: book a demo with Ionworks to compare workflows directly.
For teams choosing between simulation tools more broadly: read our PyBaMM vs GT-AutoLion comparison for the system-simulation side, and our PyBaMM vs COMSOL comparison for the finite-element side of the decision.
Frequently asked questions
Continue reading



