# freephdlabor promises peer-reviewed papers and tracks a .env

> A multiagent research framework driven by a single --task flag and a Conda environment file. Its headline claims peer-reviewed output end to end, the six documented agents contain no external reviewer, and the .env it tells you to fill with API keys sits in the tracked root.

**ltjed/freephdlabor** — freephdlabor: customizing personalized multiagent systems that researchs 24/7 on your own scientific problem

- Repository: https://github.com/ltjed/freephdlabor
- Website: https://freephdlabor.github.io/
- Stars: 728 · Forks: 80
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/ltjed-freephdlabor

## The .env you are told to fill in is a tracked file

The installation steps say to modify the `.env` file with your actual API keys, and show the three shapes to use:

```bash
OPENAI_API_KEY=your_openai_key

ANTHROPIC_API_KEY=your_anthropic_key

GOOGLE_API_KEY=your_google_key
...
```

The root of this repository lists `.env` as a tracked entry, next to `.gitignore` and `.llm_config.yaml`. That is the file the instructions ask you to write secrets into, not a `.env.example` template, so a first run in a fresh clone is one `git add` away from publishing provider credentials into history. Two related entries deserve the same attention. `logs/` and `results/` are tracked directories, so the artefacts a run produces are versioned alongside the code. And `.claude/` is tracked too, which is a client configuration directory whose contents the install page never mentions.

## Peer reviewed in the headline, publication-ready in the body

The top heading calls this the first multiagent system to produce peer-reviewed research end to end. The overview, further down the same page, uses a smaller phrase: automating the complete scientific research lifecycle from hypothesis generation through experimentation to publication-ready manuscripts. The two are not the same claim, and the agent list settles which one the code implements. Six agents are named: a manager, ideation, experimentation, writeup, reviewer and proofreading. The reviewer agent is described as reviewing and providing feedback, inside the same run that produced the manuscript. No agent reaches an external reviewer, and the sample output shipped in the repository is `assets/example_paper.pdf`. Read the overview wording as the accurate one. The same gap sits in the project self description, which promises research that runs around the clock on your own scientific problem, and in the entry point heading that promises a complete paper with real experiments, figures and citations. Citations, figures and experiments are all things the writeup and experimentation agents produce locally, so a finished PDF is evidence that the pipeline ran end to end. It is not evidence that anything checked the claims inside it.

## The comparison table names no competitor

A four row table sets the framework against a column headed Existing Systems, and every cell in that column is a cross: predetermined workflows with little to no flexibility, difficult to adapt without redesigning the entire system, intervention only at fixed checkpoints, one-off single-run attempts. No system is named, no version is given, and no paper is cited for any of the four claims. The repository does carry two long form sources, a blog post at the project homepage and a technical report on arXiv at 2510.15624, so the reasoning behind the design is documented somewhere even though the comparison itself is not checkable from this page. Continuous research is the row with the widest gap between the two columns, and it is also the row with no visible measurement behind it anywhere in the visible text.

## One flag drives everything and the second example ends mid-word

Setup is two commands against the environment file at the root:

```bash
git clone https://github.com/ltjed/freephdlabor.git
cd freephdlabor
```

```bash
conda env create -f environment.yml
conda activate freephdlabor
```

After that the entire interface is one flag:

```bash
python launch_multiagent.py --task "Your research idea or direction here"
```

Because `--task` is the only documented input and it is free text, the worked example is what teaches you the format, and that example ends mid-word at `rapid memorization, feature learning, r`. A second example asks for a single Pythia-160M model trained on a small subset of data with metrics logged every 10 steps, gradient norms, weight magnitudes and activation statistics extracted, and hidden Markov models fitted to find training phases. Read that scale carefully: the flagship example trains a 160M parameter model, which is a sensible smoke test and not a research programme. There is also no flag for a budget, a deadline, a seed or a run name, so two runs of the same task string are not obviously comparable afterwards, and nothing in the visible text explains how the manager decides that a research thread is finished.

## Six root entries the install page never explains

The tracked root holds `.claude/`, `.env`, `.gitignore`, `.llm_config.yaml`, LICENSE, README.md, assets/, environment.yml, external_tools/, the freephdlabor package, `launch_multiagent.py`, `launch_multiagent_slurm.sh`, `logs/` and `results/`. The install steps touch three of those. The structure diagram explains the package and the entry point, then stops mid-comment at `Specialized tools fo`. The cluster launcher is the largest omission: it sits at the root next to the launcher the quick start tells you to run, and nothing in the visible text mentions Slurm, a scheduler, or how the two scripts relate. The `external_tools/` directory matters too, since the customisation section tells you to bring domain specific tools from other repositories, and the provenance of what already sits there is not stated.

## Resumption is a bullet list and a pair of tracked directories

Interruption and resume is presented as one of four modular design principles, with its own list: complete workspace state, agent memory and context, research progress tracking, and what the page calls seamless resumption. The entry point is said to create the workspace directory, and nothing states where that directory lands or what the resume path looks like in practice, since there is no second command documented for picking a run back up. Meanwhile the two directories that would hold that evidence, `logs/` and `results/`, are tracked in the repository. So the artefacts of a run are versioned with the code, which is convenient for a demo and something to think about before a long run writes a large amount of data into a working tree. The list also mixes three different kinds of thing under one heading: storage that exists on disk, memory that belongs to an agent, and a capability that only matters if a process is killed. Only the first kind is something you can inspect in this repository.

## Conclusion

Two things to settle before you point this at a real problem. First, what the output actually is: six agents produce LaTeX manuscripts and an internal reviewer, which is a different thing from the peer-reviewed claim in the headline, and the difference matters if you intend to submit the result. Second, credentials. A tracked `.env` at the root plus three provider keys is a repository history problem, not just a workflow one, so move keys outside the tree before the first run and rotate anything already committed. The cluster launcher and the external tools directory are worth a look for the same reason: both ship in the repository and neither is explained in the page you install from.

## FAQ

### What does freephdlabor need before it will run?

Python 3.11 or newer, a Conda environment manager, API keys for whichever LLM providers you configure, and a CUDA compatible GPU if your experiments need computation. Setup is a clone plus `conda env create -f environment.yml` and `conda activate freephdlabor`. There are no GitHub releases, so the clone is the install path.

### Which LLM providers does freephdlabor support?

The `.env` example names OpenAI, Anthropic and Google keys, and `.llm_config.yaml` at the root is the place to customise model selection for different components. The launch script loads that configuration at start-up and the manager agent is initialised with specialised tools from it. No other provider appears in the visible configuration.

### Does freephdlabor submit papers or get them peer reviewed?

Nothing in the visible text describes submission or outside review. The writeup agent creates academic papers with LaTeX, the reviewer agent reviews and provides feedback inside the same run, and the sample output in the repository is assets/example_paper.pdf. The overview wording is publication-ready manuscripts, while the headline makes the peer-reviewed claim.

### How do I add my own agent to freephdlabor?

Extend the BaseResearchAgent class, implement the required methods such as run() and get_tools(), then register with the ManagerAgent, and the system handles coordination. Each agent keeps its own tool set under freephdlabor/toolkits/, its instructions under freephdlabor/prompts/, and its own memory, state and communication protocols.

### What does the freephdlabor example task actually run?

The worked example asks the system to train a single Pythia-160M model on a small subset of data, log metrics every 10 steps, extract gradient norms, weight magnitudes and activation statistics, then fit hidden Markov models to identify training phases such as rapid memorization and feature learning.

## Sources

- [Issues](https://github.com/ltjed/freephdlabor/issues)
- [License: MIT](https://github.com/ltjed/freephdlabor/blob/main/LICENSE)
- [ltjed/freephdlabor on GitHub](https://github.com/ltjed/freephdlabor)
- [Project website](https://freephdlabor.github.io/)
- [README](https://github.com/ltjed/freephdlabor/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ltjed-freephdlabor