Simulation for chip-design agents
The simulator your agents can afford to run a thousand times a day.
AI agents now write and fix chip designs in a loop: write, simulate, read the error, fix, simulate again. Second Loop is a SystemVerilog simulation engine built for that loop. It's priced per run, quick to start, and returns results a machine can read directly.
Now onboarding a small group of design partners.
# agent → second loop, run 1,284 of today $ sl run --top fifo_tb --seed 4471 --json { "status": "fail", "wall_ms": 212, "first_failure": { "time": "1840ns", "assert": "no_overflow", "file": "rtl/fifo.sv:57", "signals": { "wr_en": 1, "full": 1 } }, "coverage_delta": "+3.1%" }
The problem
Simulators were built for the first loop.
Agents live in the second.
The first loop is the human one: an engineer runs a test, waits, opens a waveform, thinks. The second loop is the agent's: thousands of short runs, read and acted on by software. Today's tools weren't designed for it.
Priced per seat, used per run
Commercial simulators are sold as annual seats and licence tokens. When an agent multiplies the number of runs, the bill follows, and vendors are moving to charge by agent usage.
Slow to start, for short runs
An agent's typical test is short. When compile and startup take longer than the simulation itself, the loop slows down and the compute bill goes up.
Made for eyes, not models
Logs and waveforms are built for a person at a screen. An agent needs a clear verdict: what failed, where, when, and what changed since the last run.
How it works
One call per iteration. One answer an agent understands.
Second Loop sits underneath your agent as the simulation engine. Your agent keeps its own logic; we make each turn of the loop cheap, fast and readable.
- 1The agent writes or fixes RTLDesign and testbench code, as it does today.
- 2It calls Second LoopThrough an API or command line, thousands of runs in parallel.
- 3It gets a structured verdictPass or fail, the first failure with file and line, and the coverage change, as JSON.
- ●It closes the loopFix, re-run, converge. Pay only for the runs it makes.
The engine
Built for machines that iterate.
A new simulation engine written from the ground up for agent workloads. We're building it in the open with our design partners, and we're clear about where each part stands.
Pay per run
Transparent pricing per simulation, not per seat. Your costs scale with what your agents actually do.
In developmentFast start for short runs
Optimised for the many short tests agents run, where startup time matters as much as raw speed.
In developmentAgent-readable results
Structured JSON with the verdict, the first failure pointer, assertion details and coverage deltas. No log parsing.
In developmentMassively parallel
Many independent runs per machine with a small memory footprint, so a full regression doesn't wait in a licence queue.
In developmentOpen interfaces
Standard SystemVerilog and VPI, so Python testbenches such as cocotb can plug in without a rewrite.
In developmentProof, not claims
We run our engine against your test suite, side by side with the simulator you use today, and will publish results on open benchmark suites.
Benchmarks on requestWho it's for
Teams whose simulation bill grows with every agent.
AI chip-design agent startups
You're building agents that write and verify RTL. Simulation is the inner loop of your product, and its cost and speed shape your margins.
Verification teams with big regressions
Thousands of runs every night, licences that run out, jobs that queue. You want more runs for the same budget.
Small teams on Python testbenches
FPGA and early-stage chip teams using cocotb who need a fast, affordable engine without an enterprise contract.
Design partners
Bring a test suite. We'll show you the numbers.
- We benchmark one of your designs or test suites against your current simulator.
- You see cost per run, startup time and output, side by side.
- You help shape the API your agents will call, before it ships.
- Your code and results stay private, under NDA.