Autoresearch has one well-understood shape: hill-climb a metric. Point an agent at a system, give it something it can measure, and let it propose a change, run the experiment, keep it if the number improved, revert it if it didn’t, and repeat.
What a given loop needs to do that is not well understood at all, and it keeps changing. One week you need sandboxes that start in milliseconds so you can branch a thousand of them. The next you need observability shaped a particular way to compare runs honestly. The next you need a specific compute cluster, or a different model, or a new way to score. The requirements move because the research moves.
So we built hiloop around a single principle: commit to the goal, not to the resources. The system should let you climb the metric without baking in assumptions about the sandboxes, the hardware, the harness, or the shape of the data it produces. Almost all of getting that right is about what you refuse to wire together.
Decouple
The infrastructure from the harness.
The default autoresearch setup tracks experiment state in a markdown file and trusts whatever harness you wrote to record the right thing. That ties the infrastructure to the shape of one loop. We decided the infrastructure shouldn’t know what harness you run.
The interceptor is a single binary that wraps your harness as a child process and captures what it does from the outside: its telemetry, its network calls, its output. It makes no assumption about the framework inside, and it runs the same on a laptop or in a sandbox. Normalization is generic first: we understand where the bytes came from (a process, an HTTP body, a span), not which harness produced them.
Bring your own loop, or use ours. The infrastructure underneath is identical.
Decouple
The compute from the infrastructure.
The infrastructure decides what to run and records what happened. It doesn’t own the machines, and it doesn’t own the thing that executes a sandbox.
Two seams make that real. Where compute lives is yours: an on-prem cluster, a cloud account, a pool of GPUs. The whole system installs into your environment with Helm, and your data never has to leave it. What executes a sandbox sits behind one interface (create, snapshot, fork, destroy): Firecracker microVMs today, containers or a managed provider tomorrow, with no change to anything above.
That’s what lets us ship the fastest working primitive now and grow into the harder ones (GPU state, stronger isolation) without tearing anything out. Build for today, design for the swap.
Decouple
The goal from the data.
The same logic that keeps us out of your harness keeps us out of your data model. We don’t know what question you’ll want to ask of a run, and honestly, neither do you until later.
So we capture low and reconstruct high. Record the raw stream of everything the agents did, in a deliberately narrow shape, and turn it into whatever you need at query time: a span tree to debug one run, a trajectory to compare two, a dataset to train on. The raw record is the source of truth. Every view is derived from it and rebuildable, so you can decide the goal late, change it freely, and replay history into the new shape.
We go deep on this in Telemetry and a query engine for autoresearch.
Couple
Sandbox state and observability.
Decouple, decouple, decouple. Then couple deliberately, where it earns its keep.
This is that place.
Every run sits in a lineage tree, and a fork mints a child run beneath its parent. Every snapshot, every fork, and every event the interceptor captures carries that run’s identity. Compute state and observability share one key, because they’re two halves of the same fact: what happened in an experiment, and where it sits in the tree.
That coupling buys true auditability at both layers. For any run you can see what the harness did (the prompts, the calls, the scores) and what the compute did (the snapshot it forked from, the state it diverged into), and you can ask how two branches differed since their common ancestor. Reproduce a result, review a run, or audit an entire tree of experiments, down to the bytes.
Why it’s worth it
Decoupling keeps the primitives generic, so the research can move fast: any harness, any compute, data shaped to whatever you’re proving. Coupling is where the leverage is: the lineage of what your experiments did and what actually ran, complete end to end.
We’re excited to build the infrastructure that takes autoresearch from a single-machine loop to something you run at scale. If you’d like to work with us, email us at founders@hiloop.ai.