EdgeSim, an open source bench simulator: what is in the box and where it goes

EdgeSim is the open-source bench simulator from Galois Labs: simulated instruments wired into simulated benches that PyVISA scripts, pytest, galois-edge and AI agents can't tell from real hardware. It is Apache-2.0 and covers nine instrument classes, a PyVISA backend, a pytest plugin and a live terminal console. Its public release is coming soon.

This essay is the overview: why a simulated bench, what is in the box, where Galois fits and where the roadmap goes. The snippet and its output were run against EdgeSim 0.2.0, and design claims come from the EdgeSim design spec and contracts. Six hands-on guides publish with it and make up the series; the close lists them in reading order.

Why does test engineering need a simulated bench?

A hardware test talks to an instrument on one bench, wired to one board, used by one person at a time, so test code waits between runs and rots while it waits. A simulated bench removes that wait for every part of the loop that does not need physics.

Test code runs on every push. A GitHub-hosted runner cannot reach your bench, which is why Run hardware tests in CI keeps hardware jobs on a self-hosted runner. With a virtual bench, instrument-code tests move to hosted runners and the bench job shrinks to what needs hardware.

Faults happen on schedule. A real supply does not trip its overvoltage protection on demand; a virtual one trips at a virtual time you pick, so a safe-state test is a few lines of pytest.

Agents get a bench they cannot damage. A wrong range on a virtual supply costs nothing. Can an LLM safely drive lab instruments? covers the layers that contain an agent on real hardware, and a virtual bench exercises them at no risk.

Plans are rehearsed before approval. How to review an AI-generated test plan scores a plan against a dead board, because a plan that passes when nothing powers up is broken. A virtual bench is where that run happens before any supply is energized.

What is in the box?

EdgeSim's open-source release, with the edgesim package and its edgesim[tui] console extra, is coming soon. The package carries the engine and brings galois-profiles (the profile model, converter and linter) as a dependency, with wheels for Linux, macOS and Windows on Python 3.10 and later.

One profile, three jobs. An instrument profile is one YAML file. It is the driver (typed commands with units and limits checked before anything reaches the wire), the simulation spec (sim: rules, such as an overvoltage trip that latches the output off and queues error 324) and the map an agent navigates. Fidelity is a ladder: a command typed property simulates itself, sim: rules declare behavior, and a Python behavior pack models what a profile cannot. A real instrument's profile run as a virtual one is a simulated twin, and the Galois library of 573 profiles from 135 manufacturers is the pool of instruments that can become twins. A simulated supply's behavior is text a team can read and diff, and Apache-2.0 lets a team vendor the simulator and run it on a hosted runner. Declarative instrument drivers makes the case for the format.

Benches. A bench is a topology file of nodes and wires, the same file the Galois cloud editor draws, plus optional ext.sim bags. Wires become nets and a quasi-static solver resolves each one, so a meter on a supply reads what the supply drives rather than a canned answer.

Trace. Every action becomes a typed record in edgesim.trace/1: state delta, observation and a fidelity grade. galois-edge writes the same schema for real hardware when TRACE_DIR is set, so provenance reads sim, real or replay.

EdgeSim also adapts parts of instro, Nominal's "open-source, vendor-agnostic Python library for interfacing with test equipment", and credits it in the NOTICE file that ships with the release. Open-source instrument control software compared places instro among its peers.

Source: nominal-io/instro

What does a first run look like?

The smallest useful EdgeSim program opens a bench file, sends a typed command and prints what changed. The bench is the PSU, 1 kΩ resistor and DMM example from EdgeSim's example benches, public with the release, with the supply and the meter wired to one net:

import edgesim
from edgesim import Command
 
world = edgesim.open_bench("benches/psu_resistor_dmm.bench.json")
 
(t,) = world.step(Command("sim-psu-1", "source.voltage", {"voltage": 5.0}))
print(t.delta, t.fidelity, t.status)
 
world.scpi("sim-psu-1", ":OUTPut1:STATe ON")
print(world.scpi("sim-dmm-1", ":READ?"))

{'output.voltage_setpoint[1]': (0.0, 5.0)} declared ok
b'+5.000000E+00\n'

A World owns one bench: its virtual clock, instruments, nets, seeded noise and trace. step is the single way to change it, and it returns a Transition: what changed, how far to trust the answer (declared means the profile declares the behavior) and a status. The DMM reads 5 V because a solver resolved the supply, resistor and meter as one circuit, not because anyone told the meter what to say. The same bench file answers PyVISA, SCPI sockets and pytest with the instrument code unchanged.

How does an agent use a virtual bench in Galois?

Everything above runs without an account; Galois is where the bench meets an agent. Galois is agent-driven test engineering for hardware teams: agents generate tests and instrument drivers, run them on real benches through the open-source galois-edge daemon, and turn the results into reports and a shared engineering record.

Évariste, the agent in the Galois platform, reaches a bench through that daemon. Start galois-edge with SIM_MODE and a bench file, and Évariste works the virtual instruments with the tools it uses on real ones: list_instruments, send_command, create_sequence, start_test_run and get_run_results. This is a worked example on the PSU, resistor and DMM bench; the objective is stated with its limits:

Using the PSU, resistor and DMM bench, set supply channel 1 to 5 V with a 0.1 A current limit, turn the output on, wait 500 ms, and check that the DMM reads between 4.9 V and 5.1 V. Turn the output off when the check ends.

Évariste drafts a versioned sequence. A draft cannot run until it is approved, and later edits are new versions with diffs. After approval the sequence executes through galois-edge against the virtual bench, each step records its value, limits and verdict, and "Generate a test report from the last run" produces the report. When the virtual run reads clean, the real bench is the next run, and the engineer starts it.

Two pieces are in build. The sequence rehearsal gate dry-runs every sequence on a virtual bench built from the project's topology before it can be approved, so the draft arrives with its rehearsal result. Hosted virtual edge runs that bench in Galois's cloud, so a project rehearses without a bench PC. The product overview shows the loop in the interface, and AI test automation for hardware covers it on real instruments.

Where does the bench go next?

The design spec sorts the work into milestones, and the box above is M1, in 0.2.0.

M2 is in build. Bulk acquisitions stream through galois-edge, as the console already streams its plots. A real session is recorded and replayed as a regression, and traces are written as Parquet. A container image and hosted virtual edge run a bench anywhere, Modbus TCP and framed-serial devices are simulated, a bench can be simulated straight from the cloud editor, and many seeded benches roll out in one batched call. Galois's high-fidelity behavior packs, which model specific instruments down to their quirks, arrive beside the open core and register under the edgesim.behaviors entry point, so the engine does not change when one lands.

M3 is the frontier. CAN, I2C, SPI and OPC UA devices join the bench, circuits couple transiently so an RC charge shows on the supply feeding it, and learned world models plug in behind step(). Every action already lands in one transition format over typed state, so a model that predicts the consequence of an action can sit where the solver sits. That direction is in build, not shipped.

When is EdgeSim enough, and when is something else?

A mock is enough for one instrument and a few commands. A unittest.mock stub needs nothing new to learn, and PyVISA-sim "allows you to simulate devices and therefore test your applications without having real instruments connected" (docs read October 7, 2026). EdgeSim earns its place when a test spans a bench: shared nets, coupled state, scheduled faults, a solved circuit or an agent.

Hardware is the answer for the board. A passing virtual run is evidence about the test code, the sequence and the limits. Calibration, probing, fixture contact and a regulator's real transients need the bench, and EdgeSim's quasi-static solver covers operating points rather than transients, so SPICE stays the tool for the circuit itself.

Read the fidelity grade. A stub answer is a typed default, not behavior, and galois-profiles lint warns about each such query. Treat each as a to-do.

Where to go from here

Six guides publish with this overview and make up the series. Read them in order, or jump to the instrument class on your bench:

1. Terminal instrument console: watch, edit and fault a twelve-instrument bench from the keyboard.
2. Oscilloscope simulator in Python: an AWG, RC filter and 10x probe into a scope, with the waveform block decoded to volts.
3. SMU IV sweep simulation: compliance on both signs, linear, log and list sweeps, and the buffer.
4. Spectrum analyzer simulation: center and span, RBW, detectors, markers and :TRACe:DATA? in dBm.
5. RF signal generator simulation: AM, FM and PM sidebands, sweeps and a measurable timebase.
6. Lock-in amplifier simulation: settling, noise bandwidth and a Bode sweep.

The instrument profile reference and the MCP server guide cover the Galois side. Start with the console: it shows the whole bench at once, and the other five guides each take one instrument off it.