auto-deep-researcher-24x7

Recent Updates

2026-04-22

• Added explicit compatible-API configuration, dual Claude/Codex skill installation, and safer skill-installer ownership checks.

2026-04-21

• Added an optional SSH execution backend so the controller can stay local while code edits, training, logs, PID checks, and GPU queries run on one remote host.

2026-04-19

• Added a real multi-turn worker tool-use loop with authoritative tool-result handoff, stricter CLI behavior, and safer tool-call parsing.

2026-04-18

• Added subscription-backed claude_cli and codex_cli provider modes with fail-fast provider validation and more defensive CLI subprocess handling.

2026-04-09

• Reduced token growth and tightened loop/tool safeguards with leader-history resets, no-progress fallback, and stronger path and shell protections.

2026-04-08

• Added progress tracking exports with optional Obsidian sync and local text fallback when no vault is configured.

Start In 3 Steps

If you only want the shortest path to a working experiment loop, do this:

1. Create a project folder with one file: PROJECT_BRIEF.md
2. Run /auto-experiment --project /path/to/project --gpu 0
3. Check progress with /experiment-status or optional Obsidian/local text notes

Prefer AI-guided setup? Open AI_GUIDE.md in Claude / ChatGPT / Codex and let the assistant walk you through it.

What You Actually Need

| Requirement | Required | Notes | |-------------|----------|-------| | Python 3.10+ | Yes | Runtime | | 1+ NVIDIA GPU | Yes | For training | | API key | Yes | Anthropic-compatible or OpenAI-compatible endpoint | | PROJECT_BRIEF.md | Yes | Main control file | | Project config.yaml | Optional | Only if you want to override defaults | | Obsidian vault | Optional | If absent, notes fall back to local text files |

Minimum Working Example

The smallest project you can launch looks like this:

my-first-experiment/
├── PROJECT_BRIEF.md
└── workspace/                  # auto-created

Minimal PROJECT_BRIEF.md:

# Goal
Train a ResNet-50 on CIFAR-100 to reach 80%+ accuracy.

# Codebase
Create the training code from scratch in PyTorch.

# What to Try
- Start with a basic ResNet-50 baseline.
- If accuracy < 75%, improve optimization and schedule.
- If accuracy is 75-80%, try augmentation.
- If accuracy > 80%, stop and report.

# Constraints
- Use GPU 0 only
- Max 100 epochs per run

That is enough to start. Everything else is optional refinement.

What This Project Is Good At

This project is for people who already know what experiment they want to run, but do not want to babysit the loop:

• edit code
• launch training
• monitor runs
• parse logs
• decide the next variation
• keep going while you sleep

It is not trying to replace the researcher. It is trying to take over the repetitive experiment-ops layer.

Why It Feels Different From A Simple Script

• It does not just launch one run. It keeps iterating.
• It does not just monitor. It reflects and decides the next step.
• It stays cheap because training-time monitoring makes zero LLM calls.
• It stays controllable because the human can override direction at any cycle.
• It now supports persistent progress notes in Obsidian or local text files.

How You Stay In Control

You control the research direction through three files:

• PROJECT_BRIEF.md: stable goal, constraints, allowed search space
• HUMAN_DIRECTIVE.md: temporary redirect for the next cycle
• workspace/MEMORY_LOG.md: rolling memory of results and decisions

Common control patterns:

# Keep the search narrow
- Only tune augmentation.
- Do not change the backbone.
- Keep training budget fixed.

# Make the agent stop exploring a weak direction
- If gain stays below 0.3 points for 3 runs, stop this branch.
- Return to the last trusted baseline and try a different idea.

# Force result verification
- If a result looks unusually strong, rerun with the same seed and one new seed.
- Do not claim improvement until both reproduce.

How You See Progress

You should never have to guess what the agent is doing.

• /experiment-status shows current goal, best result, cycle count, running status, and recent decisions
• /progress-report generates a structured summary
• /obsidian-sync refreshes persistent notes manually
• workspace/progress_tracking/ stores local text notes when no Obsidian vault is configured

If you want a dashboard outside the terminal:

obsidian:
  enabled: true
  vault_path: "~/Documents/MyObsidianVault"   # Optional
  auto_append_daily: true

If vault_path is empty, the same information is saved locally:

workspace/progress_tracking/Dashboard.txt
workspace/progress_tracking/Daily/YYYY-MM-DD.txt

💛 A Note on Why We Built This — and How We Hope You'll Use It

Our hope is simple: science stays pure, and the human stays in the loop.

We built this framework for one reason — to take the repetitive, mechanical parts of running deep learning experiments off the researcher's plate (launching jobs, watching GPUs, parsing logs, sweeping hyperparameters) so that more of your time can go into the part that actually matters: thinking.

If you're here because you want to spend less time babysitting training runs and more time reading, reasoning, and chasing your own ideas — welcome. That's exactly who we built this for.

A gentle thought we'd love every user to share with us:

The agent is happy to run the experiments. But please let the ideas, the interpretation, and the scientific judgment remain yours. We don't see automation and academic integrity as being in tension — quite the opposite. The hours this tool gives back are meant to be reinvested in deeper thinking, not in skipping it.

So we'd kindly ask that this project not be used to fabricate results, to generate "research" with no human in the loop, or to shortcut the parts of science that depend on a human actually understanding what they're doing. That isn't the future we want to help build — and we don't think it's the one most of you want either.

Science should stay pure. The agent can run the experiments — but the ideas, the interpretation, and the responsibility belong to the human.

学术应当保持纯粹。 Agent 可以替你跑实验，但 idea、判断与责任，请留给人来承担。我们真心希望每一位使用者都能 human in the loop 地去思考，把这个工具省下来的时间，投入到真正属于你自己的研究方向里。

科学は純粋であるべきです。 Agent は実験を走らせることができますが、アイデア・解釈・責任は、どうか人間の手に残してください。

과학은 순수해야 합니다. Agent는 실험을 대신 실행해 줄 수 있지만, 아이디어와 해석, 그리고 책임은 부디 사람의 몫으로 남겨주세요.

We trust the people who pick up this tool to take that seriously — and we built it because we believe most of you already do. Thank you for being one of them. 💛

The Core Idea

You design the experiment. The agent handles the repetitive loop.

Deep Researcher Agent:

1. Thinks — Reads your project brief, analyzes previous results, plans the next experiment
2. Executes — Modifies code/configs, runs a dry-run, launches training on GPU
3. Monitors — Watches training at zero LLM cost (just process checks + log reads)
4. Reflects — Parses results, compares with baselines, decides what to try next
5. Repeats — 24/7, without human intervention

You sleep 8 hours     → Agent runs 3 experiment cycles
You go on vacation    → Agent explores 50+ hyperparameter configs  
You write your paper  → Agent already has the results table ready

Battle-Tested Results

Not benchmarks. Real results from months of 24/7 autonomous operation across research projects.

| Metric | Result | |--------|--------| | Autonomous experiment cycles completed | 500+ | | Best single-project improvement | 52% over baseline (across 200+ auto-run experiments) | | Concurrent projects managed | 4 projects across 4 GPU servers | | Longest continuous autonomous operation | 30+ days without human intervention | | Average LLM cost per 24h cycle | ~$0.08 |

Key Innovation: Zero-Cost Monitoring

The #1 concern with running LLM agents 24/7: cost.

Most agent frameworks call the LLM every few minutes to "check progress". That's $50+/day.

Experiment Agent sleeps during training — zero API calls. It only wakes the LLM when training finishes.

                    LLM Active              Zero Cost              LLM Active
                  ┌────────────┐