alphaXiv OpenResearch: Local-First Agent Lab

Search the plain word and you get a basic-income study, a MediaWiki, a Dutch product agency and a Wikipedia entry on open science. None of those is this. alphaXiv OpenResearch is a desktop workspace, written in Rust and MIT-licensed, that takes Claude Code, Codex or OpenCode and points them at research work: reviewing literature, forming hypotheses, running experiments and producing artifacts, with everything staying on your machine. It landed on GitHub on 7 June 2026, reached 1,315 stars by 12 September, and shipped v0.2.0 on 11 September after four point releases in the week before it.

Key Takeaways:

• Local-first by design: projects, conversations, experiments, runs, logs, code and artifacts stay on your machine
• Each research direction gets its own agent session and its own isolated git worktree, so parallel lines of enquiry don't collide
• Experiments live in a git-native tree, and every run keeps an immutable archive of the commit it ran against
• The same committed snapshot runs locally, over SSH, or on Slurm, Kubernetes, Ray, Hugging Face Jobs, Modal and Tinker — publishing the repository is not required
• Install is a desktop app for macOS 11 or later, a Windows build still marked beta that needs Git for Windows, or a shell installer plus orx up

Start with the name, because it will cost you an hour otherwise

The search results for the bare word belong to other organisations entirely, and none of them has anything to do with agents. If you go looking for documentation and land on a basic-income research lab, you haven't made a mistake; the name is just crowded. Everything below is about the alphaXiv project specifically, the one at openresearch.sh whose footer says "An alphaXiv project".

What local-first means here, concretely

The word gets used loosely, so take the specific list. Projects, conversations, experiments, runs, logs, code and artifacts all stay on the machine. orx up opens a dashboard at http://127.0.0.1:4791 — loopback, not a LAN address. When you point alphaXiv OpenResearch at remote compute with orx up --remote user@host, the remote service also binds to loopback and, per the project's own note, carries no application-level authentication of its own, which tells you the threat model assumes SSH is doing that job.

For models, the local path is real rather than decorative: LM Studio, oMLX, Ollama or a custom endpoint, wired through OpenCode. So a run where neither the weights nor the corpus leaves your hardware is available, which is the whole reason a lab with an ethics board might look at this instead of a hosted product.

Parallel exploration, and the worktree trick

Here's the design decision worth copying. Give each research direction its own agent session and its own isolated git worktree, and two agents chasing different hypotheses stop overwriting each other's working tree. Anyone who has tried running two coding agents against one checkout knows exactly which failure this prevents.

On top of that sits a git-native experiment tree, where variants are tracked as a lineage rather than a folder of timestamped directories, and every run receives an immutable archive of the commit it actually ran. That last part is the difference between "I think this result came from the version with the longer context window" and knowing.

The problem it is actually solving

Reproducibility in machine-learning work fails in a boring way. Someone gets a number, writes it in a slide, and three weeks later cannot say which branch, which hyperparameters and which data snapshot produced it, because the directory it ran in has been overwritten eleven times since. Nobody sets out to lose that; it leaks away one git checkout at a time.

alphaXiv OpenResearch attacks this at the storage layer rather than with discipline. Because each direction owns a worktree, the code state that produced a run cannot be silently mutated by the next run. Because every run archives the commit it executed, the mapping from result to source is recorded rather than remembered. And because logs, diffs, files, results and artifacts stay tied to the work that produced them, the evidence travels with the claim.

None of that is clever. It's the kind of plumbing a research group builds badly for itself, in shell scripts, over about two years. Getting it in the box is the value.

Autoresearch, which is the loud part

alphaXiv OpenResearch will also run the loop without you: propose an idea, change the code, launch an experiment, read the evidence, decide what to try next, repeat. Several agents can explore different directions at once while the experiment tree keeps their lineage straight.

Whether you want that is a separate question from whether it works, and the honest position is that nobody has published independent evidence about the quality of the decisions it makes unattended. What the architecture does give you is the ability to audit them afterwards, because each step left a commit, an archive and a log. An autonomous loop you can reconstruct is a different risk from one you cannot.

Run anywhere, including places you don't own

The same committed source snapshot runs locally, over SSH, or on Slurm, Kubernetes, Ray, Hugging Face Jobs, Modal, Tinker and alphaXiv's own managed compute. Publishing the repository is not required, which matters for unpublished work. Their site also describes a compute marketplace that aggregates offerings from several providers, so renting a GPU for an afternoon is meant to happen from inside the workspace.

Which is where the local-first story meets its own edge. An autoresearch loop that keeps going all night wants something awake all night, and the laptop running your dashboard is the least reliable component in that arrangement. Zentor is a hosted cloud AI computer that holds the long-running half in an environment you reach from any machine, so the overnight loop doesn't depend on the lid staying open in a bag. That's a complement to a local install, not a replacement: the weights and the corpus can still stay where you put them.

What the interface actually gives you

The dashboard is an experiment tree rather than a chat window, and that framing choice carries most of the product. A baseline node sits at the root — "reproduce the paper", in the project's own example — and experiment nodes hang off it: test a longer context window, sweep the optimiser and schedule, tighten the evaluation harness, ablate the regulariser. Each node shows its state and how many runs it has accumulated.

What you don't get is a single conversation you scroll. The unit of work is a direction, not a thread, and alphaXiv OpenResearch keeps the evidence for a direction attached to that direction. Anyone who has hunted through four weeks of chat history for the message where a number first appeared will understand why that's the right shape.

Where it sits next to the other research harnesses

This is not the only project pointing a coding agent at research this month. Hyperresearch takes the opposite approach — a fixed sixteen-step pipeline that produces a written, adversarially audited report — and the two are not really competing. One writes the paper; the other runs the experiments and tracks which version produced which number.

If you want the general vocabulary for this layer, our piece on what an agent harness is covers it. And because local-first always turns into a hardware conversation eventually, the cost of self-hosting an agent stack is the other half of the decision.

Who should install it, and who should not

If you run experiments against a code repository and you care which commit produced which result, this is aimed squarely at you, and the desktop app means you can try it in an afternoon without committing to a stack. Groups that cannot send code or data to a third party get the strongest version of the argument, since the local-model path through OpenCode is documented rather than theoretical.

Skip it if your research doesn't touch a repository. A literature review with no code has nothing to put in a worktree, and the experiment tree is dead weight; a pipeline that writes a report is what you want, not a bench. Skip it too if you're on Windows and need this to work today, because beta plus a Git for Windows prerequisite is a combination that will eat your morning.

There's a middle case worth naming. Plenty of people want the reproducibility bookkeeping and have no interest in babysitting the machine that does it. For them the split is clean: keep alphaXiv OpenResearch and its worktrees where the data has to live, and put the long unattended stretch somewhere that stays awake.

Installing it, and the caveats

macOS gets a universal app for Apple Silicon and Intel, requiring macOS 11 or later. Windows is a Releases download, still flagged beta, and it needs Git for Windows installed first — the project tells you to read its Windows notes before starting rather than after. The CLI route is curl -LsSf https://openresearch.sh/install.sh | sh followed by orx up, on macOS and Linux.

Version numbering is worth reading carefully. v0.2.0 on 11 September follows v0.1.123 the same day, so the minor bump represents a deliberate marker rather than a long stabilisation. Four releases landed between 4 and 11 September. Treat alphaXiv OpenResearch as software under active daily change, and check the release notes before you rely on any behaviour described here, accurate as it is for September 2026.

FAQ

Is OpenResearch free?

The workspace is MIT-licensed and free to run. Two things cost money: whichever model you drive it with, and any remote compute you rent, including alphaXiv's managed option. An account on openresearch.sh is optional and exists for email updates and managed compute rather than as a gate on the software.

Does it work offline or with local models?

With local models, yes — LM Studio, oMLX, Ollama and custom endpoints are documented through OpenCode. Fully offline depends on what your agent needs to fetch; a literature review that reads the web obviously won't work without it, while a local experiment loop against local weights should.

How is it different from a hosted deep research tool?

A hosted tool sends your question out and sends a report back. alphaXiv OpenResearch keeps the project, the code, the runs and the artifacts on your machine and gives the agent a git worktree to work in, which makes it a lab bench rather than an answer service. The trade is that you run the bench.

Which agents can it drive?

Claude Code, Codex and OpenCode, with the harness and model chosen per session. That per-session choice is more useful than it sounds, since the agent that's good at reading papers is often not the one you want writing the training loop.

The name is the worst thing about it

Strip out the branding problem and alphaXiv OpenResearch is one of the more thoughtful pieces of research tooling to appear this quarter, and the reason is unglamorous: it treats reproducibility as a storage problem and solves it with git rather than with good intentions. The worktree isolation, the immutable run archives, the lineage tree — those are the parts that will still matter when the autoresearch demo stops being novel. Just don't try to find it by typing its name into a search box.