Open source

Six builds, one idea each.

Every one of these exists because something was provably missing — a gap I checked before writing a line. Each has a hard technical core rather than an API call in a wrapper, tests that run in CI, and a number I measured rather than estimated. Where a measurement came out against the idea, it says so.

The builds
nondet
deterministic simulation testing

Your suite passes five hundred times and fails once in CI, and you never reproduce it. nondet runs real async code inside a seeded scheduler that owns every source of nondeterminism — the microtask queue, timers, Date.now(), sockets. Every run becomes a pure function of one integer.

The hard part V8's microtask queue is already deterministic, so there's no compiler plugin — you take the edges and let V8 do what it does right. Time doesn't pass, it teleports to the next pending timer once nothing can run, so an eight-hour retry backoff finishes in three milliseconds. Failing seeds are shrunk on the raw choice stream, which reduces schedules, network faults and generated data with one set of generic passes.
passes 253 seeds → fails on 254 → reproduces identically 10/10 shrinks a noisy counterexample to 3 decisions, each on the boundary
Duplex
full-duplex conversational audio

Every iOS voice agent hears itself. The usual fix is muting the mic while the agent talks, which removes self-interruption by removing barge-in — the one thing that makes a voice agent tolerable. Duplex predicts what its own echo should sound like on this device and treats anything louder as a person.

The hard part The audio render thread is a real-time context: no allocation, no locks, no ARC traffic. Getting samples off it means a genuine lock-free SPSC ring buffer, verified by pushing two million samples through real threads and asserting every one arrives exactly once, in order, untorn. The AEC tail is measured per device by chirp and cross-correlation rather than assumed to be 300ms.
recovers a planted echo delay to within one sample, 10ms → 250ms spectral flatness separates voice (~1e-9) from a leaf blower (0.37–0.46)
falconer
geo-grid local rank tracking

Local Falcon charges $139/month to sample Google Maps rankings from a grid around a business. There was no open-source equivalent. This is one — geodesic grids, the metrics agencies actually report, and a heatmap you can hand a client.

The hard part, and what it disproved The plan was to chase gradient — sample where the rank surface changes fastest. Measured, it was 7% worse than a plain space-filling design, because inverse-distance error is governed by the worst-covered point and pulling samples to a boundary starves everywhere else. It ships defaulted off, and the README says why. What did pay was the geometry: a maximin design beats taking every Nth point by 9%.
60 of 169 calls — 64% cheaper — within 0.40 rank positions a "1 mile" naive grid is really 0.48 miles in Anchorage; this one isn't
dialtone
voice-agent latency harness

Every voice-AI vendor publishes a latency number, all measured differently, none including the phone network. dialtone doesn't ask the agent how fast it was — it records what it sent and what came back and recovers the timing from the audio.

The hard part A vendor SDK's timestamp excludes the inbound jitter buffer, the endpointer's own decision delay — usually the largest term and the one there's most incentive to exclude — loss concealment, and carrier codec delay. Recovering it means normalised cross-correlation on the audio itself. Scenarios come from real inbound service calls: "hello?… hello?", a phone number read in chunks, an address over a compressor.
injected 700+350ms → measured 1050.4ms (0.4ms error) the fastest agent tested also cut its callers off 41 times
tripwire
streaming schema validation

Over an API you can't touch logits, so everyone enforces structured output with a retry loop: emit four thousand tokens, parse, fail, discard, pay again. tripwire validates as the stream arrives and aborts at the first token that proves the document can't conform.

The hard part A resumable JSON lexer that survives any chunk boundary — mid-string, mid-escape, two of four hex digits into a \u sequence — plus a reachability question: can any completion of this half-written value still be valid? One asymmetry governs it. A wrong "keep going" costs tokens; a wrong "abort" kills a generation that was fine. So every check keeps going unless it can prove otherwise.
61% fewer characters on the documents that fail aborts on "esc — 15 of 59 characters — no status starts with 'e'
divergence
terminal recording diff

asciinema records terminal sessions. Nothing diffs them — so "it passed locally and failed in CI, where did they stop agreeing?" is a question nobody could answer except by scrolling two logs side by side.

The hard part The bytes in a recording aren't what the user saw; they're instructions for producing it. Two runs that displayed the same thing can share almost no bytes. So it ships a real VT100/xterm emulator — Paul Williams's DEC state machine, total by construction so a crashed program's truncated sequences recover instead of wedging the parser. Then commands are aligned with Myers before their output is compared, so one extra step doesn't poison everything after it.
two builds drew progress bars with different escape sequences → reported as identical; only the real difference surfaced

Four other ideas were checked and killed before anything was written — a Swift LLM SDK, agent record/replay cassettes, accessibility-tree computer use for macOS, sports player tracking. All four are already well served. Being the sixth entrant is worse than not building, and the research that establishes it is part of the work.