second lop LABS

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.

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.

01 / COST

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.

02 / LATENCY

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.

03 / OUTPUT

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.

  1. 1
    The agent writes or fixes RTLDesign and testbench code, as it does today.
  2. 2
    It calls Second LoopThrough an API or command line, thousands of runs in parallel.
  3. 3
    It gets a structured verdictPass or fail, the first failure with file and line, and the coverage change, as JSON.
  4. ●
    It closes the loopFix, re-run, converge. Pay only for the runs it makes.
FIRST LOOP engineer, hours SECOND LOOP agent, milliseconds

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 development

Fast start for short runs

Optimised for the many short tests agents run, where startup time matters as much as raw speed.

In development

Agent-readable results

Structured JSON with the verdict, the first failure pointer, assertion details and coverage deltas. No log parsing.

In development

Massively parallel

Many independent runs per machine with a small memory footprint, so a full regression doesn't wait in a licence queue.

In development

Open interfaces

Standard SystemVerilog and VPI, so Python testbenches such as cocotb can plug in without a rewrite.

In development

Proof, 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 request

Who it's for

Teams whose simulation bill grows with every agent.

First

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.

Next

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.

Also

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.
Become a design partner hello@secondlooplabs.com