Anyone doing deep learning research has probably lived through this loop: tweak hyperparameters -> run training -> wait 6 hours -> check the results -> tweak again -> run again. The most soul-crushing part is not the grind—it is that the whole thing is mechanical through and through. The open-source Deep Researcher Agent framework was born to solve exactly this problem: while you sleep, it is running experiments; by the time you sit down to write your paper, the results table is already ready.

What Is Deep Researcher Agent

It is an open-source framework for automating deep learning experiments. Its core function is to have an AI Agent run experiments for you nonstop, 7x24, in a THINK -> EXECUTE -> MONITOR -> REFLECT loop. It does not depend on an LLM API for monitoring (zero API overhead during training), so the cost is just 0.5 yuan per day.

Project address: https://github.com/Xiangyue-Zhang/auto-deep-researcher-24x7

The Core Workflow

At the heart of the framework is an autonomous loop with four stages:

THINK (plan the approach)

The Agent reads the project description and its memory of past experiments, analyzes the current best result, and decides what to try next. It does not just tune hyperparameters—it can also modify model code, swap the loss function, and add data augmentation strategies.

EXECUTE (write code + launch tasks)

The Agent automatically modifies code or configuration, first runs a mandatory dry-run (2 steps of forward and backward) to confirm there are no bugs, and only then submits the real training to the GPU.

MONITOR (zero-cost monitoring)

This is the single most critical design in the whole project: during training, the Agent makes no LLM API calls at all. It does only three things:

• kill -0 $PID -- check whether the process is alive
• nvidia-smi -- check whether the GPU is working
• tail -- look at the last few lines of the log

These three operations cost zero in API calls.

REFLECT (analyze the results)

Once training finishes, the Agent parses the logs, extracts metrics, compares them with the historical best, records milestones, and then starts the next round of the loop.

The Cost Logic of 0.5 Yuan a Day

An LLM Agent running 24/7—why is it so cheap?

The key is the "zero-cost MONITOR." Across a 24-hour day, training takes up more than 90% of the time, and LLM call costs during that period are zero. Only the "plan the approach" step at the start and the "look at results" step at the end need to call a large model, a few minutes each time.

Constant Memory: No Context Growth After Six Months of Running

Long-running Agents have a classic problem: the context piles up longer and longer, making them slow, expensive, and dumb. Deep Researcher Agent's answer is a two-tier memory system:

• Tier 1: the human-written project description (frozen and unchanging, at most 3000 characters)
• Tier 2: a rolling log the Agent maintains itself, with key results automatically compressed to within 1200 characters and only the 15 most recent decisions kept

Total memory stays constant at about 5000 characters. Run it for 1 day and it is this size; run it for 6 months and it is still this size.

Real-World Results

The framework has already run continuously for more than 30 days across several real research projects:

• Autonomously completed 500+ rounds of experiment loops
• Improved a single project's metric by 52% over baseline
• Managed 4 projects and 4 GPU servers at the same time
• Longest continuous run of 30+ days, with humans stepping in only five or six times

Supported Models

The framework is not locked to a single LLM; switching takes one changed line in the config:

• Anthropic family: Claude Sonnet 4.6 (fast) / Claude Opus 4.6 (strongest)
• OpenAI family: Codex 5.3 (fast) / GPT 5.4 (strongest)

Quick Start

Installation takes only two steps:

git clone https://github.com/Xiangyue-Zhang/auto-deep-researcher-24x7.git
cd auto-deep-researcher-24x7
python install.py

After installation you get 7 Claude Code / Codex slash commands that you can use directly to manage the experiment loop.

If you have no idea how to use it, the repo contains an AI_GUIDE.md file—just hand it to any AI assistant, and it will interactively walk you through the setup and your first experiment, step by step.

Mobile Monitoring

Together with the Happy Coder app (iOS / Android), you can, right from your phone:

• Check experiment progress in real time
• Get notified when training finishes or a bug appears
• Give the Agent a "change direction" instruction at any time

End-to-end encryption keeps your code and results fully private.

Who It Is For

If you are a deep learning researcher who repeatedly tunes parameters and reruns experiments before deadlines, Deep Researcher Agent can automate every mechanical step for you. You only need to supply the ideas and the judgment—leave the experiment-running to it.

References

• GitHub project address: https://github.com/Xiangyue-Zhang/auto-deep-researcher-24x7