NanoResearch

End-to-End Autonomous AI Research Engine — From Idea to Full Paper, Fully Automated

Quick Start · Showcase · Pipeline · Claude Code · Feishu Bot

🔬 NanoResearch actually runs computational experiments — it doesn't just generate code, it submits jobs to GPU clusters, collects real results, generates figures, and outputs a complete LaTeX paper backed by real experimental data. Every number, table, and chart in the paper comes from actual experiment outputs, not LLM fabrication.

📖 Table of Contents

• 📊 Real-World Output Showcase
• ⚡ CLI Demo
• 📢 News
• ✨ Key Features
• 🆚 Why NanoResearch
• 🎯 Use Cases
• 🖼️ Showcase
• CLI: Plain vs TUI
• 🔬 Pipeline
• 📦 Quick Start
• 🧬 Evo Self-Evolving Pipeline
• 🧩 Claude Code Mode
• ⚙️ Configuration
• 💻 CLI Reference
• 🍪 Examples & Demos
• 📂 Output Structure
• 💬 Feishu Bot
• 🏗️ Project Structure
• ❓ FAQ
• 🎯 Roadmap
• 📋 Requirements
• 🙏 Acknowledgements
• 🤝 Contributing
• 📝 Citation
• 📄 License

🔝 Back to top

📊 Real-World Output Showcase

Figures below are generated by NanoResearch from real experiment runs. All curves, tables, and visualizations are derived from actual training logs and execution outputs — not LLM fabrication.

Experimental Results

Main Results & Comparison

Ablation & Visualization

Every figure is produced by the pipeline from genuine experiment artifacts; all data traces back to executed runs.

⚡ CLI Demo

The command-line interface (CLI) offers both a full-screen TUI and classic streaming logs. Below is a TUI theme and interface demo (color themes and layout). For other entry points (e.g. Claude Code, Feishu bot), see the corresponding sections in this README.

🔝 Back to top

📢 News

• [2026-03] 📄 NanoResearch documentation and showcase overhaul — local image references and real-world output display.
• [2026-03] 🚀 NanoResearch v1.0 officially released — the first end-to-end autonomous AI research engine, covering literature search through LaTeX paper output.
• [2026-03] 🔬 Core capabilities: real GPU/SLURM execution, evidence-driven writing, 9-stage resumable pipeline, per-stage multi-model routing.

✨ Key Features

🆚 Why NanoResearch

🎯 Use Cases

• Research Prototyping — Quickly turn a research idea into a full experiment + paper workspace
• Autonomous Experiments — Let the system generate code, submit GPU training, and analyze results
• Benchmark Generation — Batch-run multiple topics with reproducible experiment results
• Paper Draft Assistance — Produce LaTeX drafts grounded in real experimental data
• Research Audit Trail — Complete workspaces, intermediate artifacts, and logs for full traceability

🖼️ Showcase

Break free from the manual research grind

No more debugging failed experiments, wrangling data by hand, or writing papers from scratch —
NanoResearch automates the full research workflow so you can focus on real innovation.

Overview

NanoResearch is a unified research pipeline that automates the full paper-production workflow:

• starts from a research topic
• searches and synthesizes relevant literature
• proposes an experiment blueprint
• generates runnable code and scripts
• executes locally or on SLURM
• analyzes real outputs
• generates figures
• writes a LaTeX paper draft
• reviews and revises the result

It is designed around resumable workspaces, multi-model routing, and grounded writing so that downstream paper content is tied to actual experiment evidence instead of free-form draft generation.

Why NanoResearch

Most "AI paper writers" stop at outlines or prose. NanoResearch is built for a deeper loop:

• End-to-end pipeline: topic to exportable paper workspace
• Grounded writing: writing consumes structured experiment evidence, figures, and citations
• Checkpoint + resume: failed stages can be resumed from the last saved state
• Execution-aware: supports local execution and SLURM-backed workflows
• Multi-model by stage: route ideation, coding, writing, and review to different models
• Exportable outputs: clean paper/code/figure bundles for sharing or submission prep

Use cases

• Research prototyping — quickly turn a fresh idea into a full experiment-and-paper workspace
• Benchmark generation — create repeatable topic-to-paper runs across multiple tasks
• Autonomous experimentation — let the system generate code, execute runs, and analyze outputs
• Paper drafting from evidence — produce LaTeX drafts grounded in actual experiment artifacts
• Internal research tooling — use workspaces, manifests, and stage artifacts as an auditable research log

Showcase

Generated research workspace

A typical NanoResearch run produces a clean, inspectable workspace containing:

• literature and planning artifacts
• runnable experiment code
• generated figures
• LaTeX paper sources and bibliography
• a final exported bundle for sharing or submission prep

Example outputs

Framework Overview	Generated Paper Examples
Main Results (Real Experiment Data)	Ablation Study

🔬 Pipeline

Research Topic
     ↓
 IDEATION → PLANNING → SETUP → CODING → EXECUTION → ANALYSIS → FIGURE_GEN → WRITING → REVIEW
     ↓
 Exported: paper.pdf / paper.tex / references.bib / figures / code / data

📦 Quick Start

Follow these steps to go from install to first run in about 5 minutes.

Step 1: Install

git clone https://github.com/OpenRaiser/NanoResearch.git
cd NanoResearch
pip install -e ".[dev]"

Step 2: Configure

{
  "research": {
    "base_url": "https://your-openai-compatible-endpoint/v1/",
    "api_key": "your-api-key",
    "template_format": "neurips2025",
    "execution_profile": "local_quick",
    "writing_mode": "hybrid",
    "max_retries": 2,
    "auto_create_env": true,
    "auto_download_resources": true,
    "ideation": { "model": "your-model", "temperature": 0.5, "max_tokens": 16384, "timeout": 600.0 },
    "planning": { "model": "your-model", "temperature": 0.2, "max_tokens": 16384, "timeout": 600.0 },
    "code_gen": { "model": "your-model", "temperature": 0.1, "max_tokens": 16384, "timeout": 600.0 },
    "writing": { "model": "your-model", "temperature": 0.4, "max_tokens": 16384, "timeout": 600.0 },
    "figure_prompt": { "model": "pro/gpt-5.5", "temperature": 0.5, "max_tokens": 4096, "timeout": 300.0 },
    "figure_code": { "model": "pro/gpt-5.5", "temperature": 0.1, "max_tokens": 16384, "timeout": 600.0 },
    "figure_gen": {
      "model": "gpt-image-2",
      "image_backend": "openai",
      "base_url": "https://your-image-endpoint/v1/",
      "api_key": "your-image-api-key",
      "temperature": null,
      "timeout": 300.0
    },
    "review": { "model": "your-model", "temperature": 0.3, "max_tokens": 16384, "timeout": 300.0 }
  }
}

Environment variable overrides: NANORESEARCH_BASE_URL / NANORESEARCH_API_KEY / NANORESEARCH_TIMEOUT

Step 3: Validate & Run

# Validate config
nanoresearch run --topic "Adaptive Sparse Attention Mechanisms" --dry-run

# Run the full pipeline
nanoresearch run --topic "Adaptive Sparse Attention Mechanisms" --format neurips2025 --verbose

# Resume from checkpoint (if a stage fails)
nanoresearch resume --workspace ~/.nanoresearch/workspace/research/{session_id} --verbose

# Export paper
nanoresearch export --workspace ~/.nanoresearch/workspace/research/{session_id} --output ./my_paper

Step 4: Expected Output

After the pipeline completes, you will have paper figures and LaTeX sources backed by real experiment data.

🧬 Evo Self-Evolving Pipeline

evo is NanoResearch's self-evolving pipeline for personalized research automation. It combines skill evolution, memory evolution, and feedback-aware planner/router adaptation so the system can reuse experience and better align with user preferences across research cycles.

When to use evo

• You want the system to accumulate reusable skills and project memory across research cycles.
• You want plans to adapt to user preferences, resource constraints, target venues, and feedback.
• You want planning to explicitly request proposed-method, baseline, ablation, optimization/history, and complexity experiments, with paper writing grounded only in real artifacts.

From user initialization to paper export

# 1. Initialize or refresh the user profile, preferences, and runtime settings
nanoresearch init

# 2. Start the self-evolving full workflow
nanoresearch run --pipeline evo --topic "your research topic" --format neurips2025 --verbose

# 3. Resume if a stage fails or the process is interrupted
nanoresearch resume --workspace ~/.nanoresearch/workspace/research/{session_id} --verbose

# 4. Inspect stage status and artifacts
nanoresearch status --workspace ~/.nanoresearch/workspace/research/{session_id}
nanoresearch inspect --workspace ~/.nanoresearch/workspace/research/{session_id}

# 5. Export the final paper package
nanoresearch export --workspace ~/.nanoresearch/workspace/research/{session_id} --output ./paper_export

What evo produces

evo still runs the nine-stage backbone: IDEATION -> PLANNING -> SETUP -> CODING -> EXECUTION -> ANALYSIS -> FIGURE_GEN -> WRITING -> REVIEW. The difference is that it continuously updates and reuses the user profile, skill bank, project memory, and feedback routing across stages.

Machine-checkable experiment artifacts are typically written to:

~/.nanoresearch/workspace/research/{session_id}/experiment/configs/experiment_matrix.json
~/.nanoresearch/workspace/research/{session_id}/experiment/results/metrics.json
~/.nanoresearch/workspace/research/{session_id}/experiment/results/run_manifest.json
~/.nanoresearch/workspace/research/{session_id}/experiment/results/final_metrics.json
~/.nanoresearch/workspace/research/{session_id}/experiment/results/optimization_history.csv
~/.nanoresearch/workspace/research/{session_id}/experiment/results/pareto_front.json

The writing stage reads only measured execution results, analysis reports, and figure artifacts. If an experiment category or metric has no real artifact, NanoResearch narrows the evidence scope or writes it as a limitation / future-work item rather than filling in synthetic numbers. OpenAlex can be used anonymously; configure OPENALEX_API_KEY only when you need higher literature-search rate limits.

🤖 Recommended Models

🧩 Claude Code Mode

In addition to the Python CLI, NanoResearch can be driven directly through Claude Code — no API keys required.

Quick Start

git clone https://github.com/OpenRaiser/NanoResearch.git
cd NanoResearch
claude
/project:research "Your Research Topic Here"

Available Commands

Codex Integration

In addition to Claude Code, NanoResearch now exposes a project-level entrypoint for Codex. Codex does not need a second pipeline or a dedicated --mode codex flag. It should reuse the existing CLI, workspace, manifest, and PaperMode behavior already implemented in the repo.

How to use it

# 1. Clone the project
git clone https://github.com/OpenRaiser/NanoResearch.git
cd NanoResearch

# 2. Open the repo in Codex
# 3. Ask Codex to read AGENTS.md first

Codex entrypoint: AGENTS.md

How Codex should interpret the repo

• Treat the repository as an end-to-end autonomous research pipeline, not a generic coding project
• Prefer the existing nanoresearch CLI / workspace / orchestrator behavior
• Map user intent onto the existing research, ideation, planning, experiment, analysis, writing, review, status, and resume flows
• Keep outputs compatible with the existing workspaces and manifest.json

Survey and original modes

Codex should follow the same topic-prefix convention used by the CLI:

• original: Topic
• survey:short: Topic
• survey:standard: Topic
• survey:long: Topic

These prefixes already feed the repo's PaperMode parsing logic. Codex should reuse that behavior rather than introducing a new interface.

Execution profiles

Execution Profiles

Model Routing

NanoResearch routes different stages to different model configs through a unified configuration layer, letting you mix models by task instead of forcing one model to do everything.

Literature Search API Keys (optional)

The IDEATION stage uses OpenAlex and Semantic Scholar. Works without API keys (anonymous), but with lower rate limits.

Paper Formats

Templates are auto-discovered from nanoresearch/templates/. Built-in formats:

nanoresearch run --topic "Graph Foundation Models for Biology" --format neurips2025

💻 CLI Reference

nanoresearch --help

🍪 Examples & Demos

Official examples and advanced usage to get you started with NanoResearch:

👉 Browse Examples & Demos

# Full pipeline + verbose logs
nanoresearch run --topic "Adaptive Sparse Attention" --format neurips2025 --verbose

# Export and inspect
nanoresearch export --workspace ~/.nanoresearch/workspace/research/{session_id} --output ./paper_out

🔝 Back to top

📂 Output Structure

my_paper/
├── paper.pdf
├── paper.tex
├── references.bib
├── figures/
├── code/
├── data/
└── manifest.json

~/.nanoresearch/workspace/research/{session_id}/
├── manifest.json          # Pipeline state tracker
├── papers/                # Literature search artifacts
├── plans/                 # Experiment blueprints and analysis
├── experiment/            # Generated experiment code + results
├── figures/               # Generated paper figures
├── drafts/                # Paper drafts and review feedback
├── output/                # Final export (main.tex / main.pdf)
└── logs/                  # Run logs

💬 Feishu Bot

NanoResearch includes a built-in Feishu (Lark) bot for triggering pipelines, checking status, and receiving papers directly in chat — no terminal needed.

pip install lark-oapi

export FEISHU_APP_ID="cli_xxx"
export FEISHU_APP_SECRET="xxx"

{
  "feishu": {
    "app_id": "cli_xxx",
    "app_secret": "xxx"
  }
}

nanoresearch feishu          # Start the bot
nanoresearch feishu -v       # Verbose logging

Supported Commands

You can also chat naturally — the bot acts as an AI research assistant with conversation memory. When the pipeline finishes, it automatically sends the compiled paper.pdf to the chat.

🏗️ Project Structure

nanoresearch/
├── nanoresearch/
│   ├── cli.py              # 🖥️ CLI entry point
│   ├── config.py           # ⚙️ Configuration management
│   ├── agents/             # 🧠 Stage-specific agents
│   │   ├── ideation.py     #    Literature search & hypothesis
│   │   ├── planning.py     #    Experiment blueprint
│   │   ├── coding.py       #    Code generation
│   │   ├── execution/      #    Local/cluster execution
│   │   ├── analysis/       #    Results analysis
│   │   ├── figure_gen/     #    Figure generation
│   │   ├── writing/        #    Paper writing
│   │   └── review/         #    Review & revision
│   ├── pipeline/           # 🔄 Orchestrators & state machine
│   ├── schemas/            # 📋 Pydantic data models
│   ├── prompts/            # 💬 YAML prompt templates
│   ├── templates/          # 📄 LaTeX Jinja2 templates
│   └── latex/              # 🔧 LaTeX auto-fixer
├── mcp_server/             # 🔌 MCP tool server
├── skills/                 # 🎯 Claude Code skills
└── pyproject.toml

❓ FAQ

conda install -c conda-forge tectonic

🎯 Roadmap

• 9-stage unified pipeline
• Local GPU + SLURM cluster execution
• Claude Code integration mode
• Feishu bot
• Multi-conference templates (NeurIPS / ICML / arXiv)
• Checkpoint & resume with multi-model routing
• More demos and tutorials
• Benchmark evaluation suite
• Web workspace UI
• More paper format support

🔝 Back to top

🤝 Contributing

We welcome contributions from developers and researchers.

👥 Community

Join our WeChat group for discussion, Q&A, and collaboration. Scan to join:

🔝 Back to top

📋 Requirements

• Python 3.10+
• OpenAI-compatible API endpoint (for text model stages)
• Optional: image model access (for some figure generation)
• tectonic or pdflatex (for PDF compilation)

🙏 Acknowledgements

• claude-scholar — Scientific research skills for Claude Code

⭐ Star History

📝 Citation

@software{nanoresearch2026,
  title = {NanoResearch},
  author = {OpenRaiser},
  year = {2026},
  url = {https://github.com/OpenRaiser/NanoResearch}
}

📄 License

MIT