Arbor splits research into a Coordinator and an Executor, and gates merges on held-out data
A generalist autonomous research agent — runs experiments, researches, and iteratively optimizes, autonomously.
At a glance
- What is it?
- An Apache-2.0 autonomous research agent that grows a hypothesis tree instead of discarding failures, with every experiment run in its own git worktree. Its literature search silently degrades on Python 3.10 and 3.11 because the alphaXiv client needs 3.12, and its usage guide stops mid-sentence.
- Who is it for?
- Arbor is for a team with a metric, a codebase and patience for many small experiments, since what it offers is discipline rather than a smarter prompt: a persistent tree of what has been tried, a held-out split that gates merges, and worktree isolation so a failed experiment cannot damage anything. It is the wrong tool for a one-shot task, because the overhead of a tree and a Coordinator pays off only across many iterations.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 12 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- RUC-NLPIR/Arbor1,149 ★ · +69
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| RUC-NLPIR/Arbor | 1.1k | 1.1k |
69 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Two agents, and the split is by role not by size
Arbor runs two cooperating agents and the division of labour is the whole design. The Coordinator is the research director: it maintains the Idea Tree, drives the search, and dispatches experiments. The Executor is the research engineer: given one idea, it faithfully implements the code changes, runs the experiment in an isolated git worktree, and reports evidence. So the agent that decides what to try never writes the code, and the agent that writes the code never decides what is worth trying. That is a meaningful separation for a system that edits code while judging results, because a single loop that does both tends to grade its own work. The three command-line entry points mirror it, exposing an `arbor`, an `executor` and a `coordinator` command.
Six steps, and the fifth one is where memory happens
The cycle repeats in six steps. Observe: the Coordinator re-grounds itself in the Idea Tree, reading the active frontier, constraints, ancestor insights, recent evidence and the current best artifact. Ideate: it picks a parent node and proposes children that refine, correct or extend what the tree already knows. Select: it chooses the most promising pending leaves, balancing the current best direction against unresolved alternatives. Dispatch: those hypotheses go to independent Executors in fresh worktrees, evaluated on the dev signal. Backpropagate: each result, score, insight and branch is recorded and the lesson abstracted upward so ancestor nodes and future ideas inherit it. Decide: merge, prune, continue, leave pending, or stop, with held-out validation deciding merges.
The tree is the memory, and pruning is an explicit outcome
The framing is that Arbor grows a hypothesis tree instead of forgetting what failed, and the news entries make that concrete. Each run leaves concrete reusable findings, such as a dataset quirk that helped or a trap to avoid, and the next similar task recalls them at intake so the agent starts from experience rather than from scratch. Note what that means for cost: the same dead end is not rediscovered, but the context grows, and the Observe step reads ancestor insights every cycle. The Decide step lists pruning alongside merging, so a branch that does not pan out is recorded and then set aside rather than kept alive. Whether the tree is pruned aggressively or not is not something the README quantifies, and it is the parameter that decides how much context each cycle carries.
Merges require held-out data and a margin you configure
Experiment discipline is described as real rather than aspirational: Executors iterate on a dev split, validate on a held-out test split, and merge only gains that clear a configurable margin. Each executor works in its own git worktree, so `main` is never touched until you merge. That is three separate protections and each one addresses a specific failure mode. The dev and test split addresses tuning to the signal you are optimising. The margin addresses accepting noise as improvement. The worktree addresses a half-finished edit corrupting a working state. The cost is that a run needs a real dataset you can split and a metric you can compute, which is why the project describes itself as general purpose over anything with a target to improve and a metric to measure, from model training to harness engineering to data synthesis.
Three delivery modes, and only one of them needs a key
The repository presents three ways in and the difference is who pays for reasoning. The native CLI runtime, a Python package with the `arbor` command, is for real research runs with the dashboard, checkpoints, executor tools and merge discipline, and it needs an API key configured through `arbor setup`. Keyless harness integration uses `arbor install` plus `arbor mcp`, or the Claude Code plugin, to run Arbor inside a coding agent using that agent's own model, which matters for subscription plans where there is no key to hand over; Arbor supplies deterministic tools only. The Agent Skill Suite in `skills/` needs no installation at all, being instructions plus a stdlib fallback helper. The demo entry point reflects the third option and is billed as taking 30 seconds with no API key and no config:
pip install arbor-agent && arbor replay --demo # watch the hypothesis tree grow liveA browser demo is offered as well, at a page hosted alongside the documentation, for looking at a run without installing anything.
Literature search quietly disappears below Python 3.12
The dependency list carries a comment that is worth reading as documentation of a real constraint. `alphaxiv-py` requires Python 3.12 or newer, so it is declared behind a version marker and is simply skipped on Python 3.10 and 3.11, with the backend degrading gracefully and printing a clear runtime message. The package itself declares a `requires-python` floor of 3.10, so a 3.10 install succeeds and appears complete. What you lose is the keyless literature-search backend that grounds ideas in prior work and powers `arbor idea-check`. The design decision is defensible, keeping the base install available on 3.10, but the failure mode is a feature that quietly stops existing rather than an install that fails.
Model choice is broad, and the client libraries are pinned to floors
Backends are named as Anthropic, the OpenAI Responses API, and OpenAI-compatible providers reached through LiteLLM, with DeepSeek, Gemini, Qwen, vLLM and Ollama given as examples. The corresponding libraries are declared with lower bounds rather than pins: `anthropic>=0.52.0`, `openai>=1.30.0`, `litellm>=1.55.0`, plus `httpx`, `requests`, `tiktoken`, `pypdf`, `typer`, `rich`, `pyyaml`, `prompt-toolkit`, `pydantic` and `pydantic-settings`. Optional extras are kept small and purposeful: a `docs` extra pulling mkdocs-material and mkdocs-static-i18n, and an `mcp` extra for running Arbor's deterministic tools as an MCP server, deliberately optional so the base install stays lean. The version is dynamic in the manifest and the released tags run 0.1.2, 0.1.3 and 0.1.4, the last published on 2026-07-12.
The claims are the project's own, on six tasks
The headline is that Arbor beats Claude Code and Codex by 2.5 times on the same compute budget, and the comparison table gives three rows of it: BrowseComp accuracy at 53.33 for Claude Code, 50.00 for Codex and 67.67 for Arbor; Terminal-Bench 2.0 pass rate at 71.70, 73.59 and 77.36; and a Math-Reasoning Data gap of 8.33, 6.25 and 20.83. A further figure is quoted as 86.36 percent Any-Medal on MLE-Bench Lite, attributed to GPT-5.5. Six tasks in total are claimed, with the rest behind a results link. Treat these as the authors' numbers on their own harness, not as an independent measurement, and note that the last push to the repository is dated 2026-09-08 while the newest tag is from July, so the running code and the released code are not the same thing.
Editorial conclusion
Arbor is for a team with a metric, a codebase and patience for many small experiments, since what it offers is discipline rather than a smarter prompt: a persistent tree of what has been tried, a held-out split that gates merges, and worktree isolation so a failed experiment cannot damage anything. It is the wrong tool for a one-shot task, because the overhead of a tree and a Coordinator pays off only across many iterations. Three things to check before a run. Decide which of the three delivery modes you want, because the native CLI needs an API key and the two harness modes do not, and that difference is about who pays for reasoning. Confirm your Python version, since literature search is gated to 3.12 and above while the package itself installs on 3.10. And read the benchmark claims as the project's own, reported on six tasks with a comparison against Claude Code and Codex, not as an independent measurement.
Frequently asked questions
What is Arbor and how does it work?
Arbor is an autonomous research agent from RUC-NLPIR, Apache-2.0 licensed, that takes a benchmark and a goal, then proposes hypotheses, edits code and runs real experiments. Two agents cooperate: a Coordinator that maintains the Idea Tree and dispatches work, and an Executor that implements one idea in an isolated git worktree and reports evidence.
Does Arbor need an API key?
It depends on which of the three delivery modes you use. The native CLI runtime needs an API key configured through `arbor setup`. The keyless harness integration via `arbor install` plus `arbor mcp` uses the host agent's own model, and the standalone Agent Skill Suite needs no key at all, being instructions plus a stdlib fallback helper.
What is the hypothesis tree in Arbor?
It is the structure the Coordinator maintains in place of a flat history. Findings from each run, such as a dataset quirk or a trap to avoid, are recorded and abstracted upward so ancestor nodes and future ideas inherit them, so later proposals start from earlier experience rather than from scratch.
What Python version does Arbor require?
The package declares Python 3.10 or newer. The `alphaxiv-py` literature-search client requires 3.12, so it is declared behind a version marker and is skipped on 3.10 and 3.11, where the search backend degrades gracefully with a runtime message.
How does Arbor decide whether to keep a result?
Executors iterate on a dev split, then validate on a held-out test split, and only gains clearing a configurable margin are merged. Each executor works in its own git worktree, so the main branch is untouched until a merge, and the Coordinator's decide step can merge, prune, continue, leave a node pending or stop.
Which models and backends can Arbor use?
Anthropic, the OpenAI Responses API, and OpenAI-compatible backends through LiteLLM, with DeepSeek, Gemini, Qwen, vLLM and Ollama named as examples. The provider and model are configured during `arbor setup`.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ruc-nlpir-arbor)Star history chart for your README
[](https://hysenlabs.com/projects/ruc-nlpir-arbor)Was this useful?