Run Autonomous AI Research Locally with autoresearch

What this is, in plain English

This is an experiment in “autonomous AI research”: a small setup where an AI agent runs its own tiny machine-learning experiments in a loop, on your laptop’s ordinary processor (CPU), with no expensive cloud GPU. You hand it a research question, and it edits the training code, runs a short experiment, looks at the result, and decides what to try next, over and over, on its own.

Be honest about the level: this is for people comfortable with code and machine learning. The point of the source is that you do not need a giant framework, just a tight loop, but you still fork a repository, define an experiment, and lean on a capable coding assistant. So it is advanced. This page explains what it is, what it is good for, and the realistic shape of running it.

What you can use it for

• Explore a research question cheaply. Test whether an idea has legs on a CPU before spending on big GPU runs.
• Learn how agentic research works. Watch an AI plan, change code, run, evaluate, and iterate, the core loop of automated research.
• A self-contained project. A final-year or side experiment that runs entirely on your own machine.
• Rapid, small iterations. Many tiny experiments quickly, rather than one slow expensive one.

Tools you need

• autoresearch (free): the open-source repository that runs the autonomous experiment loop.
• A coding assistant (mixed): the author used Codex (paid) for planning and dependency checks; a free assistant works too, with less reasoning depth.
• GitHub and a code editor (free): to fork, clone, and edit the project.

How it actually works

You define the experiment, then let the loop run it. The realistic shape:

1. Fork and clone the repo. Get your own copy of autoresearch on your machine.
2. Open it in a coding assistant. Load the project so the assistant can read and help modify it.
3. Check the prerequisites. Have the assistant confirm Python and the needed libraries are installed and the base training steps are ready. (Missing dependencies are the usual reason setup fails.)
4. Define your experiment in program.md. Write a standalone file describing exactly what to investigate (the author’s tested whether adding a self-reflection step improved the agent’s decisions), and keep the base repo rules so the original constraints hold.
5. Tune the run environment. Ask the assistant to optimize the setup for local runs without changing the experiment’s design.
6. Run the loop. autoresearch reads your program.md, edits the training script (train.py) as needed, runs short experiments, evaluates the results, and decides the next step, reporting metrics as it goes.

Words you’ll see, explained

• Autonomous agent: a program that plans and acts on its own toward a goal, here, running research experiments.
• Training loop: the repeated cycle of training a model a little, checking it, and adjusting.
• train.py: the script that trains the model; the agent edits this between experiments.
• program.md: the file where you write what the experiment should investigate.
• CPU vs GPU: the CPU is your computer’s general processor; a GPU is the faster chip usually needed for big AI training. This runs on CPU to stay free.
• Dependencies: the libraries the project needs installed to run.

Original source

Based on a blog post by javz arguing that autonomous AI research does not need a giant framework, using the open-source autoresearch repository to run experiments locally in a tight loop.

Notes & variations

• Do you even need this? For a one-off test, running experiments by hand is simpler. The autonomous loop pays off when you want many small iterations explored automatically.
• Free-tier alternative: swap the paid Codex for a free assistant (like Copilot’s free tier) for the planning and dependency work.
• Common pitfall: missing Python libraries. Install and verify dependencies before running, or the loop fails at the start.
• Tip for better results: write a specific, focused program.md. The clearer the question and the success criteria, the more useful the agent’s research loop.