Compound Research

Software that improves itself.

Compound Research builds your software, instruments it as it goes, then comes back to research what's slowing it down and ship the fixes. A software factory and an autoresearch engine, working as one stack.

Request early access See how it works

An illustrative tech tree for a product search service.

Build, instrument, research, improve. Then again.

The improvement loop Build leads to Instrument, then Research, then Improve, then back to Build. Research is the step being worked on now. BuildInstrumentResearchImprove Compound Research

  1. Build

    The factory plans the work as a tech tree, splits it into small tasks, and builds them in parallel, with tests at every step.

  2. Instrument

    Metrics and traces, such as OpenTelemetry, go in while the software is being built, not after something breaks.

  3. Research

    A week or a month later, the research engine comes back, reads what the software has been doing, finds the bottlenecks and writes benchmarks for them.

  4. Improve

    Candidate fixes are tested against those benchmarks. The winners go back to the factory, which builds them in, and the next check-in is scheduled.

Compound Research runs the same loop on itself. The factory built the research engine, and the research engine found the bottlenecks in the factory's own infrastructure, from its test runners to its job scheduler and message queue, which the factory then fixed.

Planned like a tech tree.

If you've played a strategy game, you know the shape. You push far enough down one branch to unlock the next, work that branch for a while, then come back with what you learned and unlock more of the first.

Compound Research plans both building and research this way. Every node is a piece of work with prerequisites, a way to measure it and a result. Dead ends are pruned and kept on record. What works unlocks what comes next.

Build and research unlock each other Build progresses from a specification through a search endpoint to traces and metrics. Those unlock research to find the bottleneck and benchmark the fix. Research unlocks a batched scoring path in Build, which unlocks the next research check-in. BuildResearch Spec anddata modelSearch endpointTraces and metricsFind thebottleneckBenchmark the fixBatchedscoring pathNext check-in
Build and research take turns unlocking each other.

More than a coding agent with a goal.

A coding agent works through one task at a time and stops when the task looks done. Compound Research plans the whole tree first, runs many branches in parallel, scores every change against a benchmark, and keeps a record of what didn't work.

Plans the whole tree

Work is a tree of tasks with prerequisites, not a single to-do list, so independent branches run at the same time.

Measures instead of guessing

Every candidate change is scored against a benchmark written for that bottleneck. Only the winners get built in.

Remembers dead ends

Pruned branches stay on record, so the next check-in starts where the last one stopped instead of trying the same idea again.

Point it at anything you can measure.

Inference and kernels

Find where speed and cost are being lost in model serving, and search kernel and serving changes against real benchmarks.

Drug discovery

Search candidate pipelines and screening setups against the assays and scores your team already trusts.

Semiconductor research

Explore design and process variants against simulation and test metrics, with a record of every branch tried.

Your own system

If it has an objective you can measure, such as latency, cost, accuracy or yield, Compound Research can build the harness and research it.

Try it early.

We're starting with a small group of teams. Tell us what you'd point Compound Research at and we'll get in touch.