Auto-claude-code-research-in-sleep (ARIS ⚔️🌙)

· · · · · · · · 💬 Join Community ·

🌱 ARIS is a methodology, not a platform. What matters is the research workflow — take it wherever you go.

💡 Use ARIS as a skill-based workflow in Claude Code / Codex CLI / Cursor / Trae / Antigravity / GitHub Copilot CLI / OpenClaw / DeepSeek Harness — enjoy any way you like!The executor drives, an independent model (Codex MCP by default) reviews. Alternative model combinations, including ModelScope-hosted models, need no Claude or OpenAI API.

📦 Those are the skills installed directly. Want it in one command? ARIS also ships as a standalone CLI and as plugins: · · ·

❗ codex-cli 0.154.0 removed codex mcp-server — the entry point every ARIS reviewer call used. No impact on ARIS: the codex MCP server is now ARIS's own bridge over codex exec (mcp-servers/codex-exec/), same tools, same results, all 82 skills unchanged, ultra and per-thread resume intact. One re-registration is all it takes — already installed? → Quick Start step 2b · new install → step 2 · what changed.

🧩 The ARIS family — same method, other jobs. One line each; the details live in their own repos.

— EasyAIOffer: 34 bilingual ML / LLM interview cheat sheets on one page — derivations, from-scratch PyTorch, 25 questions each. 希望大家秋招轻松一点 🌱

· — two sides of one disease. HERO: a ~550-token block for CLAUDE.md / AGENTS.md against the four shapes agents over-defend in (Hashing, Edge cases, Rubrics, Overbuild), bounding what the agent proposes, never what it looks for. Anti-Autoresearch: 61 integrity signals into a deterministic, reviewer-ready report — fabrication forensics, not an AI-text detector.

— ARIS goes multimodal: a rough story in, a movie told in still frames out, every scene checked by another model; the same loop draws clean method diagrams (/method-figure).

— a tiny always-on-top macOS widget that lights up 🔴 when a session waits for your approval; cd aris-monitor && ./run.sh. Many windows? Claude Fleet by @tianyilt is the full dashboard.

🔥 ARIS-Code CLI — 独立安装版 · English | ⬇️ Download · — v0.4.28: ARIS_REASONING_EFFORT works on the Anthropic channel, tool calls through {}-placeholder relays fixed, OS proxy honoured. v0.4.27: launching and quitting the REPL leaves no empty session file. v0.4.26: the fable alias and /model now point at Fable 5.1 (default stays Opus 5). v0.4.25: the Codex reviewer works again on codex-cli ≥ 0.154 (built-in codex exec bridge, nothing to register), /since takes you back to your last input, /resume lists sessions by index, Windows multi-line paste fixed (pending confirmation), 83 bundled skills on GPT-6-Astra.

📰 ARIS-Code v0.4.28 (2026-09) — latest: ARIS_REASONING_EFFORT works on the Anthropic channel (#446), tool calls through relays that send a {} placeholder no longer fail (#444), and the OS proxy on Windows / macOS is used without exporting HTTPS_PROXY (#401). v0.4.27: launching and quitting the REPL no longer leaves an empty session file, and /resume lists only sessions with messages (#439 follow-up). v0.4.26 made Fable 5.1 the fable alias and the first /model entry (the default executor stays Opus 5). v0.4.25 is the reviewer-bridge release: codex-cli 0.154 removed codex mcp-server, so every Codex review from ARIS-Code died on an updated codex. The reviewer now runs over a built-in codex exec bridge — no mcpServers.codex entry, old entries migrate in memory, thread records interoperate with ARIS's Python bridge. Also: /since replays everything after your last input (folded like the live display, /since full for complete output), /resume lists sessions with indices and shows where you stopped (#439), Windows multi-line paste no longer submits line by line (#430, pending confirmation), the Windows shim message carries the native installer (#428), and the bundle moves to 83 skills on GPT-6-Astra. Recent headliners: v0.4.24 — Claude 5 model refresh (Opus 5 default, Fable 5 tier, availability chain) and . Caps a 24-release run (v0.4.5 → v0.4.28); per-release detail below. Credits: , , , , , , , , , , , , .

v0.4.28 (2026-09-28) — ARIS_REASONING_EFFORT now works on the Anthropic channel (#446): low / medium / high / xhigh / max for the main session and subagents; unset, requests are unchanged. ARIS_MAX_TOKENS raises the output cap when a high effort runs into it. autoCompactEnabled: false in settings turns automatic compaction off. 🐛 #444 tool calls through relays that send a {} placeholder no longer fail with invalid tool input JSON. 🌐 System proxy on Windows / macOS is used without exporting HTTPS_PROXY (#401, by @JasmineLCY); NO_PROXY=* connects directly as before. Upgrading: if you already export ARIS_REASONING_EFFORT, have an OS proxy, or have autoCompactEnabled: false in settings, read the upgrade notes.

v0.4.27 (2026-09-19) — launching and quitting the REPL no longer leaves an empty session file; /resume lists only sessions with messages (#439 follow-up).

v0.4.26 (2026-09-16) — Fable 5.1: the fable alias now resolves to claude-fable-5-1, /model lists Fable 5.1 first (Fable 5 stays selectable) and the system-prompt identity names it; the default executor remains claude-opus-5 (the Mythos tier is $10/$50 vs Opus 5's $5/$25, so the default does not move). Saved executor_model values are ids, not aliases, and are untouched. Pricing already matched on fable; a test pins 5.1. Tests unchanged (aris-cli 225 + 4 e2e / runtime 252 / tools 71 / commands 6). Codex MCP (gpt-6-astra xhigh) gate: GO.

中文版 README | English

🌙 Let Claude Code do research while you sleep. Wake up to find your paper scored, weaknesses identified, experiments run, and narrative rewritten — autonomously.

🪶 Radically lightweight — no infrastructure, zero lock-in. The entire skill layer is plain Markdown files. No framework to learn, no database to maintain, no Docker to configure, no daemon to babysit. Every skill is a single SKILL.md readable by any LLM — swap Claude Code for Codex CLI, OpenClaw, Cursor, Trae, Antigravity, Copilot CLI, Windsurf, or your own agent and the workflows still work. Fork it, rewrite it, adapt it to your stack.

💭 Why not self-play with a single model? Using Claude Code subagents or agent teams for both execution and review is technically possible, but tends to fall into local minima — the same model reviewing its own patterns creates blind spots.

Think of it like adversarial vs. stochastic bandits: a single model self-reviewing is the stochastic case (predictable reward noise), while cross-model review is adversarial (the reviewer actively probes weaknesses the executor didn't anticipate) — and adversarial bandits are fundamentally harder to game.

💭 Why two models, not more? Two is the minimum needed to break self-play blind spots, and 2-player games converge to Nash equilibrium far more efficiently than n-player ones. Adding more reviewers increases API cost and coordination overhead with diminishing returns — the biggest gain is going from 1→2, not 2→4.

Claude Code's strength is fast, fluid execution; Codex (GPT-6-Astra xhigh) is slower but more deliberate and rigorous in critique. These complementary styles — speed × rigor — produce better outcomes than either model talking to itself.

🧿 Want the strongest possible reviewer? Add — reviewer: oracle-pro to any skill to route reviews through GPT-5.5 Pro via Oracle MCP. Pro-level reasoning for proof verification, experiment auditing, and final stress tests. Works with API key or free browser mode. Setup →

Contents

1. More Than Just a Prompt
2. What's New · changelog
3. Quick Start · install + first run
4. Features
5. Score Progression (Real Run)
6. Community Showcase — Papers Built with ARIS
7. Awesome Community Skills & Extensions
8. Workflows · 13 named pipelines (W1 / W1.5 / W2 / W3 / W4 / W5 / W6 / Wiki / WM + Effort / Assurance / Oracle)
9. Setup · prerequisites / install / update / usage / GPU server config
10. Customization · per-skill config knobs
11. Alternative Model Combinations · GLM / MiniMax / Kimi / etc.

---

1. 🎯 More Than Just a Prompt

These are full pipelines — you can also use each workflow independently. Already have an idea? Skip to Workflow 1.5. Have results? Jump to Workflow 3. Got reviews? Jump to Workflow 4. Want persistent memory? Enable Research Wiki. See Quick Start for all commands and Workflows for the full breakdown.

Basic mode — give ARIS a research direction, it handles everything:

/research-pipeline "factorized gap in discrete diffusion LMs"

🔥 Targeted mode — got a paper you want to improve? Give ARIS the paper + the code:

/research-pipeline "improve method X" — ref paper: https://arxiv.org/abs/2406.04329, base repo: https://github.com/org/project

ARIS reads the paper → finds its weaknesses → clones the codebase → generates ideas that specifically fix those weaknesses with that code → runs experiments → writes your paper. Like telling a research assistant: "read this paper, use this repo, find what's missing, and fix it."

Mix and match: ref paper only = "what can be improved?", base repo only = "what can I build with this code?", both = "improve this paper using this code."

🛠️ Build a feature — already know what to build?

/research-implement-feature "add KV-cache reuse to the decoder" — base repo: https://github.com/org/project

Spine first, then one feature at a time, each with a runnable check. Every choice the request left open is written to an assumption ledger before the code that depends on it, and a different model family then reads the raw diff for the ones that went undeclared. It reports "the checks passed", never "the method works". Contributed by @heroarmor.

🔥 Rebuttal mode — reviews just dropped? Don't panic. ARIS reads every concern, builds a strategy, and drafts a rebuttal that's grounded, structured, and under the character limit:

/rebuttal "paper/ + reviews" — venue: ICML, character limit: 5000

Three safety gates — rebuttal will NOT finalize if any fails:

• 🔒 No fabrication — every claim maps to paper/review/user-confirmed result
• 🔒 No overpromise — every promise is user-approved
• 🔒 Full coverage — every reviewer concern is tracked

Two outputs: PASTE_READY.txt (exact char count, paste to venue) + REBUTTAL_DRAFT_rich.md (extended version for manual editing).

Parameter	Default	What it does
venue	ICML	Target venue (ICML/NeurIPS/ICLR/CVPR/ACL/AAAI/ACM)
character limit	—	Required. Hard character limit for rebuttal text
quick mode	false	Stop after parsing + strategy (Phase 0-3). See what reviewers want before drafting
auto experiment	false	Auto-run supplementary experiments via /experiment-bridge when reviewers ask for new evidence
max stress test rounds	1	How many times GPT-6-Astra xhigh stress-tests the draft
max followup rounds	3	Per-reviewer follow-up round limit

After acceptance — your paper is in, now prepare the presentation:

/paper-slides "paper/"     # → Beamer PDF + PPTX + speaker notes + Q&A prep
/paper-poster-html "paper/" # → measurement-gated HTML/CSS poster → print-ready PDF

💡 From idea to paper to podium — one toolchain. 🌱

2. 📢 What's New

⚠️ Any entry that touches skills: bash tools/smart_update.sh --apply pulls it.

• 2026-10-19 — 🔀 Choose reviewers inside the complete Claude Code and Codex skill packs — use — reviewer: or project configuration to select Codex, Gemini/Antigravity, Grok, or Claude Code through your configured reviewer tools. See the routing guide and Codex guide. The Claude Code MCP bridge now respects the requested working directory and records the CLI-reported model, including configured providers such as DeepSeek. Same-family reviews remain provisional. (#473, #472)
• 2026-10-19 — 📚 Catch bibliography field errors with /citation-crosscheck — compare local .bib entries with records freshly fetched from paper sources, then export a side-by-side spreadsheet of author, year, venue, DOI, and arXiv ID discrepancies. Available for Claude Code and Codex, alongside the existing citation audit. (#371; thanks @dty0606)
• 2026-10-19 — 🔬 Bounded parallel work for research workflows — idea generation, literature extraction, and proof checking now share fan-out rules: capped worker batches, coverage records, and sequential fallback when parallel execution is unavailable. Workers collect candidates and evidence; designated reviewers retain final judgments. (; thanks )

• 2026-09-28 — 📚 Real papers stop being reported as hallucinated citations (#445, #447, #450; thanks @ilya-pershin and @AfonsoZhang). arXiv sometimes refuses Python's HTTP client with a 406 for minutes while curl gets through; verify_papers.py read that refusal as "paper not found" and one user saw a 47% hallucination rate on 38 real papers. A 406 now goes through curl, and a refusal (406 / 401 / 403) is verify_pending, never unverified. Set SEMANTIC_SCHOLAR_API_KEY and title checks use it. Seen a suspicious hallucination rate recently? Re-run with --no-cache once. Also in this round: five skills can now actually invoke the sub-skills their text tells them to (#440, @Jeremy-xuan); concurrent watchdog registrations no longer overwrite each other (#443, @hiro-nikaitou); xhigh is described as the regular reviewer tier it is (#442, @dreamworld2023).

• 2026-09-16 — 🧩 ARIS is a Claude Code plugin now (#437, thanks ). → → once → restart. Setup registers the Codex reviewer bridge that ships inside the plugin, so the reviewer works on codex-cli 0.154+ out of the box. Plugin skills are typed with the prefix (); they call each other by short name internally. Codex CLI reads the same repo as a plugin too ( → ) and gets the Codex-native mirror. Cursor, Trae and DeepSeek Harness keep their own routes.

3. 🚀 Quick Start

# 1. Install skills — project-local symlinks (recommended)
git clone https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep.git
bash Auto-claude-code-research-in-sleep/tools/install_aris.sh ~/your-project   # symlinks ARIS skills into <project>/.claude/skills/
# (prefer a global install instead? cp -r Auto-claude-code-research-in-sleep/skills/* ~/.claude/skills/)
# (don't need all 87? --list-groups / --groups X,Y / --skills X — see "Selective install" below)

# 1b. Update later (when upstream changes)
cd Auto-claude-code-research-in-sleep && git pull
bash tools/smart_update.sh --apply   # updates safe skills, flags your personal customizations
# (NEW upstream skills need confirmation — --add-new to accept all non-interactively)

# Optional Codex mirror managed project install
bash tools/install_aris_codex.sh ~/your-codex-project

# Managed Codex project update
cd Auto-claude-code-research-in-sleep && git pull
bash tools/install_aris_codex.sh ~/your-codex-project --reconcile

# Copied Codex installs only (not for projects installed by install_aris_codex.sh)
bash tools/smart_update_codex.sh --local ~/.codex/skills
bash tools/smart_update_codex.sh --local ~/.codex/skills --apply

# 2. Codex reviewer (review skills call GPT through it) — run from the directory you cloned into in step 1
npm install -g @openai/codex && codex login       # one-time ChatGPT login; the reviewer model comes from ~/.codex/config.toml
claude mcp add codex -s user -- python3 "$(pwd)/Auto-claude-code-research-in-sleep/mcp-servers/codex-exec/server.py"
# then restart Claude Code; `claude mcp list` must show:  codex: python3 …/codex-exec/server.py - ✔ Connected

# 2b. Already had ARIS before 2026-09-11? codex-cli 0.154 removed `codex mcp-server`, so the old registration is dead.
cd Auto-claude-code-research-in-sleep && git pull   # brings mcp-servers/codex-exec/ (git pull is enough; smart_update only syncs skills)
claude mcp remove codex -s user
claude mcp add codex -s user -- python3 "$(pwd)/mcp-servers/codex-exec/server.py"
# restart Claude Code, check `claude mcp list` as above. Skills need no change. Do it on codex 0.153 too — it works there and survives the update.
# Cursor / Trae / Antigravity / Copilot CLI: same "codex" key, command python3 + that path — see the adaptation guides in docs/.
# Installed by copying skills/ without a clone? Clone the repo anywhere and point at its server.py; the file is self-contained.

# 3. Use in Claude Code
claude
> /idea-discovery "your research direction"  # Workflow 1 — be specific! not "NLP" but "factorized gap in discrete diffusion LMs"
> /experiment-bridge                         # Workflow 1.5 — have a plan? implement + deploy + collect results
> /auto-review-loop "your paper topic or scope"  # Workflow 2: review → fix → re-review overnight
> /paper-writing "NARRATIVE_REPORT.md"       # Workflow 3: narrative → polished PDF
> /rebuttal "paper/ + reviews" — venue: ICML    # Workflow 4: parse reviews → draft rebuttal → follow-up
> /resubmit-pipeline "paper/" — venue: NeurIPS  # Workflow 5: port a polished paper to a new venue (text-only, no new experiments)
> /paper-talk "paper/" — venue: ICLR            # Workflow 6: paper → Beamer + PPTX talk + speaker notes + assurance audits
> /research-pipeline "your research direction"  # Full pipeline: Workflow 1 → 1.5 → 2 → 3 end-to-end
> /research-wiki init                           # 📚 Enable persistent research memory (one-time)
> /meta-optimize                                # Meta: analyze usage logs → propose skill improvements

Don't need all 87 skills? See Selective install below for group/skill-level picks.

Optional Grok CLI bridge: grok-exec exposes grok / grok-reply using your existing Grok CLI login, with grok-4.7 + xhigh defaults, persistent sessions, progress and cancellation. It is a separate MCP service; installing it does not change the reviewer routing of existing skills.

Selectable CLI reviewers: antigravity-exec and grok-exec support the complete packs through — reviewer: antigravity / grok; see the backend contract. The legacy — reviewer: agy still uses gemini-review.

Give ARIS persistent memory across sessions. Papers, ideas, failed experiments — nothing is forgotten:

# In Claude Code:
> /research-wiki init                         # creates research-wiki/ in your project
# That's it. From now on, /research-lit auto-ingests papers, /idea-creator reads
# the wiki before brainstorming (and writes ideas back), /result-to-claim updates
# claim status. Failed ideas become anti-repetition memory for future ideation.

Run these in your normal terminal (not inside Claude Code) to enable passive usage logging:

# One-time setup in your project directory
mkdir -p .claude .aris/meta tools/meta_opt
cp Auto-claude-code-research-in-sleep/templates/claude-hooks/meta_logging.json .claude/settings.json
cp Auto-claude-code-research-in-sleep/tools/meta_opt/*.sh tools/meta_opt/
chmod +x tools/meta_opt/*.sh
# Then start Claude Code — hooks are active immediately
claude

Events are logged to both project-level (.aris/meta/events.jsonl) and global (~/.aris/meta/events.jsonl) logs. After 5+ workflow runs, run /meta-optimize to see data-driven improvement proposals. Use /meta-optimize --global to analyze trends across all your projects.

📝 Templates available! See templates/ for ready-to-use input templates for every workflow — research brief (Workflow 1), experiment plan (Workflow 1.5), narrative report (Workflow 3), paper plan (Workflow 3).

🔎 Optional: DeepXiv progressive retrieval

pip install deepxiv-sdk

Then use /deepxiv directly or opt into it from /research-lit with — sources: deepxiv or — sources: all, deepxiv.

🔎 Optional: Exa AI-powered web search

pip install exa-py
export EXA_API_KEY=your-key-here

Then use /exa-search directly or opt into it from /research-lit with — sources: exa or — sources: all, exa. Covers blogs, docs, news, and research papers with built-in content extraction.

🔎 Optional: Keenable web search (no API key needed)

export KEENABLE_API_KEY=your-key-here   # optional, only raises rate limits

Then use /keenable-search to search the web (title, URL, and page-text snippet per result) or fetch a URL as markdown. Works without a key and needs no extra Python packages.

🔎 Optional: Firecrawl web search and scraping

export FIRECRAWL_API_KEY=your-key-here

Then use /firecrawl-search to search the web with full-page markdown for each result, or to scrape a URL (HTML or PDF) to markdown. No extra Python packages needed.

🗑️ Uninstall: To remove ARIS skills without affecting your own personal skills:

cd Auto-claude-code-research-in-sleep && ls skills/ | xargs -I{} rm -rf ~/.claude/skills/{}

All pipeline behaviors are configurable via inline overrides — append — key: value to any command:

Parameter	Default	What it does
AUTO_PROCEED	true	At selection checkpoints, report the top idea and continue in the same turn. Set false to ask for explicit approval before committing GPU time
human checkpoint	false	Pause after each review round so you can read the score, give custom modification instructions, skip specific fixes, or stop early
sources	all	Which literature sources to search: zotero, obsidian, local, web, semantic-scholar, deepxiv, exa, gemini, openalex, or all. Note: semantic-scholar, deepxiv, exa, gemini, and openalex must be explicitly listed — not included in all
arxiv download	false	Download top relevant arXiv PDFs during literature survey. When false, only fetches metadata (title, abstract, authors)
DBLP_BIBTEX	true	Fetch real BibTeX from DBLP/CrossRef instead of LLM-generated entries. Eliminates hallucinated citations. Zero install
code review	true	GPT-6-Astra xhigh reviews experiment code before GPU deployment. Set false to skip
wandb	false	Auto-add W&B logging to experiment scripts. Set true + configure wandb_project in CLAUDE.md. /monitor-experiment pulls training curves from W&B
illustration	gemini	AI illustration in Workflow 3: gemini (default, needs GEMINI_API_KEY), mermaid (free), or (skip)

/research-pipeline "your topic" — AUTO_PROCEED: false                          # pause at idea selection gate
/research-pipeline "your topic" — human checkpoint: true                       # pause after each review round to give feedback
/research-pipeline "your topic" — sources: zotero, web                         # only search Zotero + web (skip local PDFs)
/research-pipeline "your topic" — sources: all, deepxiv                        # default sources plus DeepXiv progressive retrieval
/research-pipeline "your topic" — sources: all, exa                            # default sources plus Exa AI-powered web search
/research-pipeline "your topic" — sources: all, gemini                         # default sources plus Gemini discovery
/research-pipeline "your topic" — sources: all, openalex                       # default sources plus OpenAlex citation graph
/research-pipeline "your topic" — arxiv download: true                         # download top arXiv PDFs during literature survey
/research-pipeline "your topic" — difficulty: nightmare                        # maximum adversarial review before submission
/research-pipeline "your topic" — effort: beast                               # all knobs to maximum — top-venue sprint
/research-pipeline "your topic" — effort: beast, reviewer: oracle-pro         # beast + GPT-5.5 Pro reviewer — ultimate mode
/research-pipeline "your topic" — effort: lite                                # quick exploration, save tokens
/research-pipeline "your topic" — effort: max, review_rounds: 3               # max effort but cap review at 3 rounds
/research-pipeline "your topic" — AUTO_PROCEED: false, human checkpoint: true  # combine options
/proof-checker "paper/" — reviewer: oracle-pro                                # Pro-level proof verification

The runtime's sandbox settings provide a configured baseline, while a tool request may also carry sandbox-related overrides. In the legacy compatibility mode, the effective request can therefore differ from the values written in settings.json.

To make the configured policy authoritative, enable strictMode:

{
  "sandbox": {
    "enabled": true,
    "strictMode": true
  }
}

With strictMode: true, the runtime ignores these LLM-supplied overrides: dangerouslyDisableSandbox, namespaceRestrictions, isolateNetwork, filesystemMode, and allowedMounts. The configured sandbox policy remains in effect even when a tool call requests a different value. This is opt-in so existing configurations keep their legacy behavior by default.

Run aris doctor to inspect the currently reported sandbox state. strictMode controls whether tool requests can override the runtime configuration; it does not replace the host operating system's permissions, filesystem protections, or network policy.

Important: ARIS skills pin the reviewer explicitly (model: gpt-6-astra + a per-tier reasoning effort) in every fresh call — your ~/.codex/config.toml no longer silently decides the reviewer. Still set model = "gpt-6-astra" there (recommended): it covers codex-native/mirror sessions and anything that doesn't pin. ultra/max effort needs codex-cli ≥ 0.144.1 + a session restart.

Choose a reviewer in Codex: install the full skills/skills-codex/ pack and select — reviewer: claude-code, antigravity, or grok. See the backend contract for bridge setup and session rules.

The old Claude/Gemini partial overlays are frozen for existing installations; migrate safely to the full pack. The historical Claude and Gemini guides describe those legacy installations.

Want the Codex mirror install chain? Use tools/install_aris_codex.sh for managed project installs and tools/smart_update_codex.sh for copied Codex installs. The Claude scripts remain the mainline entry points for Claude projects.

The base Codex mirror defaults to a fresh Codex reviewer: same-family reviews remain provisional. Other routes require actual model identities and a completed, in-scope review before cross-family acceptance; a backend selection alone is insufficient. Submission and deterministic verification gates still apply.

See full setup guide for details and alternative model combinations if you don't have Claude/OpenAI API.

4. ✨ Features

ARIS chains 87 composable skills across the whole research lifecycle — literature & novelty → idea discovery → GPU experiments → autonomous review loop → paper writing → peer review — with cross-model adversarial review (Claude executes · GPT-6-Astra xhigh reviews · optional GPT-5.5 Pro via Oracle), anti-hallucination DBLP/CrossRef citations, a persistent Research Wiki, flexible model backends, human-in-the-loop checkpoints, and optional Feishu / Zotero / Obsidian / GPU integrations.

🔥 And it scales to any agent's ultracode-style deep mode — the breadth/firepower pass adapts to the runtime (Claude Code ultracode + workflows on Opus 4.8, Codex spawn_agent, or plain sequential), feeding three roles: breadth · cross-model review → accuracy · research wiki → memory. However a loop is driven, it reports to the same cross-model jury + research wiki — it can drive, never acquit.

• 📊 87 composable skills — mix and match, or chain into full pipelines (/idea-discovery, /auto-review-loop, /paper-writing, /research-pipeline). See full catalog →

• 🔍 Literature & novelty — multi-source paper search (Zotero + Obsidian + local PDFs + arXiv/Scholar) + cross-model novelty verification

• 💡 Idea discovery — literature survey → brainstorm 8-12 ideas → novelty check → GPU pilot experiments → ranked report

• 🔄 Auto review loop — 4-round autonomous review, 5/10 → 7.5/10 overnight with 20+ GPU experiments

• 📝 Paper writing — narrative → outline → figures → LaTeX → PDF → auto-review (4/10 → 8.5/10), one command. Anti-hallucination citations via DBLP/CrossRef

• 🤖 Cross-model collaboration — Claude Code executes and GPT-6-Astra reviews; in Copilot CLI, /auto-review-loop uses the native complementary rubber-duck model and verifies the actual cross-family pair from host events. Optional: — reviewer: oracle-pro → GPT-5.5 Pro via Oracle

• 📝 Peer review — review others' papers as a conference reviewer, with structured scoring and meta-review

• 🖥️ Review-driven experiments — when GPT-6-Astra says "run an ablation", Claude auto-writes the script, rsyncs to GPU, runs in screen, collects results, folds back into the paper. Configure server in CLAUDE.md (setup), or rent from with

ARIS ships 87+ skills across literature, ideation, experiments, audit, writing, talks, patents, and meta-utilities — the full catalog (role / category / requirements per skill) lives in docs/SKILLS_CATALOG.md to keep this README scannable.

Use case	Start here
End-to-end research (idea → paper)	/research-pipeline
Idea discovery + method refinement	/idea-discovery
Run experiments from a plan	/experiment-bridge
Auto review → fix → re-review	/auto-review-loop
Narrative → polished PDF	/paper-writing
Reply to peer reviews	/rebuttal
Port a paper to a new venue	/resubmit-pipeline
Paper → conference talk	/paper-talk
Persistent research memory	/research-wiki
Patent drafting (CN / US / EP)

→ Browse all 87 skills by category in the full catalog →

---

5. 📈 Score Progression (Real Run)

A real overnight 4-round run on an ML research project — the AI reviewer's score climbed 5.0/10 (borderline reject) → 7.5/10 (review-ready) as the loop autonomously ran 20+ GPU experiments, rewrote the narrative framing, and killed claims that didn't hold up, all without human intervention.

Round	Score	What Happened
Initial	5.0/10	Borderline reject
Round 1	6.5/10	Added standard metrics, discovered metric decoupling
Round 2	6.8/10	Key claim failed to reproduce, pivoted narrative
Round 3	7.0/10	Large seed study killed main improvement claim
Round 4	7.5/10 ✅	Diagnostic evidence solidified, submission ready

6. 🏆 Community Showcase — Papers Built with ARIS

Real projects that used the full ARIS pipeline end-to-end. The scores listed are AI-review signals (CSPaper / Stanford Agentic Reviewer), not venue acceptances — and since ARIS optimizes through AI-review loops, high AI scores are an expected byproduct, not proof of acceptance (human reviewers still bring literature / venue / community judgment an AI reviewer misses). Used ARIS for a paper? Open an issue / PR to be featured!

Paper	AI-review signal	Submission status	Built by	Notes
CS Paper Submission	CSPaper 8/10 — AI reviewer recommendation: "Top 50% of accepted papers, clear accept"	Submitted to a CS conference; awaiting official feedback	@DefanXue & @Monglitay	Full ARIS pipeline: idea → experiments → auto-review → paper writing. The quote is from CSPaper's simulated review, not an official venue review.
AAAI 2026 Paper Submission	Stanford Agentic Reviewer 7/10 — AI reviewer recommendation: "Good paper, accept"	Submitted to AAAI 2026 Main Technical; awaiting official decision	@xinbo820-web	Pure Codex CLI (ARIS-Codex skills). The 7/10 signal comes from an AAAI-style Stanford Agentic Reviewer run, not an official AAAI acceptance result.
UAV-CC	Under review	Submitted to IEEE TGRS	@wxx827	UAV change captioning benchmark. Claude Opus 4.6 (executor) + Codex GPT-5.5 xhigh (reviewer) + Cursor Opus 4.6 (assist). PDF →

7. 🧩 Awesome Community Skills & Extensions

Domain-specific skills and external projects contributed by the community. PRs welcome — just add a skills/your-skill/SKILL.md and open a PR!

💡 How to use: Community skills are not auto-wired into core workflows. To use one, ask your executor (Claude Code / OpenClaw / etc.) to read the skill's SKILL.md, then plug it into the appropriate workflow stage based on the description below.

🎉 Community Skills (15): research-refine · experiment-plan · research-refine-pipeline · grant-proposal · paper-poster (deprecated → paper-poster-html) · paper-slides · mermaid-diagram · proof-writer · comm-lit-review · dse-loop · idea-discovery-robot · formula-derivation · paper-illustration · ·

🌐 External Projects & Docs (16): rosetta · open-source-hardening-skills · CitationClaw · auto-hparam-tuning · paper-to-course · deep-research-skills · Antigravity Adaptation Guide · OpenClaw Adaptation Guide · Cursor Adaptation Guide · Codex+Claude Review Bridge · Trae Adaptation Guide · MiniMax-AI/cli · posterly · Claude Fleet · anti-defensive-writing-Skill · OrcaReplay

🙌 Thanks to every contributor! We fold the tables below to keep the README readable — but every skill and project here is equally valued. PRs always welcome!

Name	Domain	Description	Codex MCP?
🔬 research-refine	General	Turn a vague idea into a problem-anchored, implementation-oriented method proposal. Best inserted between /idea-discovery and /auto-review-loop	Yes
🧪 experiment-plan	General	Turn a refined proposal into a claim-driven experiment roadmap with ablations, budgets, and run order	No
🧭 research-refine-pipeline	General	One-shot chain: /research-refine → /experiment-plan for method refinement plus experiment planning	Yes
📝 grant-proposal	General	Grant proposal drafting (KAKENHI/NSF/NSFC/ERC/DFG/SNSF/ARC/NWO). Chains /research-lit → /novelty-check → /research-review → /paper-illustration	Yes
🎤 paper-slides	General	Conference talk slides (beamer → PDF + PPTX) with speaker notes, full talk script + Q&A prep. Auto slide count from talk type	Yes
🖼️ paper-poster	General	DEPRECATED — redirect stub to the core (measurement-gated HTML/CSS pipeline); the legacy LaTeX implementation lives in git history

Name	Domain	Description
🪨 rosetta	Pro-tier ChatGPT MCP	Programmatic access to ChatGPT Pro / gpt-5.5-pro / DeepResearch from Node, via Chrome CDP Fetch interception + WebSocket second-leg streaming. Ships an MCP server for Claude Code / Codex / Cline — alternative implementation path to Oracle MCP for — reviewer: oracle-pro style high-tier review. Supports multi-turn, parallel concurrency, live token deltas, 15-min idle-timeout watchdog (long Pro thinks survive). MIT, by @SyntaxSmith
📣 anti-defensive-writing-Skill	Press-release writing principle	"A paper is a launch, not a progress report": twelve rules against defensive writing — organize around the strongest advantage, pick the contest you win, every experiment has an argumentative duty, no self-weakening language. Skill (CN/EN) + copy-paste prompt. Four of its rules are folded into ARIS's writing contract. MIT, by @Adkid-Zephyr
🛡️ open-source-hardening-skills	DevOps / OSS	10-skill pipeline to harden research code into production-ready open-source projects — audit, refactor, test, CI, docs, review
📊 CitationClaw	General	Citation impact analysis — input paper title → citation crawling, scholar identification, tiered analysis, HTML dashboard
🚀 Antigravity Adaptation Guide	General	Use ARIS skills in Google Antigravity — native SKILL.md support, dual model (Claude Opus 4.6 / Gemini 3.1 Pro), MCP setup, EN + guides

8. 🔄 Workflows

These skills compose into a full research lifecycle. Each workflow can be used independently or chained together:

• Exploring a new area (e.g., writing a survey)? Start with Workflow 1 → /idea-discovery
• Have a plan, need to implement and run? Workflow 1.5 → /experiment-bridge
• Already have results, need iterative improvement? Workflow 2 → /auto-review-loop
• Ready to write the paper? Workflow 3 → /paper-writing (or step by step: /paper-plan → /paper-figure → /paper-write → /paper-compile → /auto-paper-improvement-loop)
• Got reviews back? Need to rebuttal? Workflow 4 → /rebuttal — parse reviews, draft safe rebuttal, follow-up rounds
• Full pipeline? Workflow 1 → 1.5 → 2 → 3 → submit → 4 → /research-pipeline + /rebuttal — from idea through submission and rebuttal
• Need a multi-session proof campaign? Workflow 7 → /proof-orchestrator — run-directory proof runs, GPT Pro handoff packages, cross-run continuation
• Want ARIS to remember and learn? 📚 /research-wiki init — persistent memory across sessions. Papers, ideas, failed experiments compound over time
• Want ARIS to improve itself? Workflow M → /meta-optimize — analyze usage logs, propose skill improvements, reviewer-gated

⚠️ Important: These tools accelerate research, but they don't replace your own critical thinking. Always review generated ideas with your domain expertise, question the assumptions, and make the final call yourself. The best research comes from human insight + AI execution, not full autopilot.

Full Pipeline 🚀

/research-lit → /idea-creator → /novelty-check → /research-refine → /experiment-bridge → /auto-review-loop → /paper-writing → submit → /rebuttal → accept! 🎉
  (survey)      (brainstorm)    (verify novel)   (refine method)   (implement+deploy)  (review & fix)      (write paper)   (send)   (reply to reviewers)
  ├────────────── Workflow 1: Idea Discovery ──────────────┤ ├ Workflow 1.5 ─┤ ├── Workflow 2 ──┤ ├── Workflow 3 ──┤         ├── Workflow 4 ──┤

                                     📚 research-wiki (persistent memory — papers, ideas, experiments, claims)
                                        ↕ reads before ideation, writes after every stage, failed ideas = anti-repetition memory

                                              /meta-optimize (Workflow M — runs independently, improves ARIS itself)
                                                 ↑ reads .aris/meta/events.jsonl (accumulated from all runs above)

Workflow 1: Idea Discovery & Method Refinement 🔍

"What's the state of the art? Where are the gaps? How do we solve it?"

Don't have a concrete idea yet? Just give a research direction — /idea-discovery handles the rest:

1. 📚 Survey the landscape (recent papers, open problems, recurring limitations)
2. 🧠 Brainstorm 8-12 concrete ideas via GPT-6-Astra xhigh
3. 🔍 Filter by feasibility, compute cost, and quick novelty search
4. 🛡️ Validate top ideas with deep novelty check + devil's advocate review
5. 🧪 Pilot top 2-3 ideas in parallel on different GPUs (30 min - 2 hr each)
6. 🏆 Rank by empirical signal — ideas with positive pilot results rise to the top
7. 🔬 Refine the top idea into a problem-anchored proposal via iterative GPT-6-Astra review
8. 🧪 Plan claim-driven experiments with ablations, budgets, and run order

The output is a ranked IDEA_REPORT.md plus a refined proposal (refine-logs/FINAL_PROPOSAL.md) and experiment plan (refine-logs/EXPERIMENT_PLAN.md) for the top idea. Dead-end ideas are documented too, saving future exploration.

┌─────────────────────────────────────────────────────────────────┐
│              Idea Discovery & Method Refinement                  │
│                                                                  │
│   /research-lit    /idea-creator    /novelty-check               │
│   (find papers)    (brainstorm)     (verify novelty)             │
│         │               │                │                       │
│         ▼               ▼                ▼                       │
│   ┌──────────┐    ┌──────────┐     ┌──────────┐                │
│   │ Scan     │───▶│ Generate │────▶│ Check if │                │
│   │ local    │    │ 8-12     │     │ idea is  │                │
│   │ papers + │    │ ideas    │     │ novel    │                │
│   │ search   │    │ + rank   │     │          │                │
│   └──────────┘    └──────────┘     └──────────┘                │
│                         │                │                       │
│                         ▼                ▼                       │
│                   ┌──────────┐     ┌──────────┐                │
│                   │ Filter   │────▶│ External │                │
│                   │ by cost, │     │ LLM      │                │
│                   │ novelty  │     │ evaluates│                │
│                   └──────────┘     └──────────┘                │
│                                          │                       │
│                   /research-refine       ▼                       │
│                   (refine method)   ┌──────────┐                │
│                         │          │ Freeze   │                │
│                         ▼          │ problem  │                │
│                   ┌──────────┐     │ anchor + │                │
│                   │ Iterate  │◀───▶│ refine   │                │
│                   │ until    │     │ method   │                │
│                   │ score≥9  │     └──────────┘                │
│                   └──────────┘          │                       │
│                         │               ▼                       │
│                   /experiment-plan  ┌──────────┐                │
│                         │          │ Claim-   │                │
│                         ▼          │ driven   │                │
│                   ┌──────────┐     │ experiment│               │
│                   │ Plan     │────▶│ roadmap  │                │
│                   │ runs     │     └──────────┘                │
│                   └──────────┘                                  │
│                                                                  │
│   Typical flow:                                                  │
│   1. /research-lit "discrete diffusion models"                   │
│   2. /idea-creator "DLLMs post training"                         │
│   3. Review ranked ideas, pick top 2-3                           │
│   4. /novelty-check "top idea" (deep verification)               │
│   5. /research-review "top idea" (critical feedback)             │
│   6. /research-refine "top idea" (problem anchor + method)       │
│   7. /experiment-plan (claim-driven roadmap)                     │
│   8. /run-experiment → /auto-review-loop                         │
└─────────────────────────────────────────────────────────────────┘

Skills involved: research-lit + idea-creator + novelty-check + research-review + research-refine-pipeline

💡 One-command shortcut: /idea-discovery "your research direction" runs this entire workflow automatically.

🔄 Human-in-the-loop: At each AUTO_PROCEED-controlled selection checkpoint, true reports results and continues in the same turn; false asks for your feedback before continuing. If you request changes, tell it what's missing — it refines the prompt and regenerates. Explicit gates such as Feishu interactive approval remain user-controlled.

⚙️ Pilot experiment budgets (max hours, timeout, GPU budget) are configurable — see Customization.

📝 Blog post: Claude Code 两月 NeurIPS 指北

Workflow 1.5: Experiment Bridge 🔗

"I have a plan. Now implement it, deploy it, and get me initial results."

Already have an experiment plan (from Workflow 1 or your own)? /experiment-bridge turns it into running code:

1. 📋 Parse the experiment plan (refine-logs/EXPERIMENT_PLAN.md)
2. 💻 Implement experiment scripts (reuse existing code, add proper argparse/logging/seeds)
3. 🔍 GPT-6-Astra code review — cross-model review catches logic bugs before wasting GPU hours (code review: true by default)
4. ✅ Sanity check — run the smallest experiment first to catch runtime bugs
5. 🚀 Deploy full experiment suite to GPU via /run-experiment
6. 📊 Collect initial results and update the experiment tracker

┌─────────────────────────────────────────────────────────────────┐
│                Workflow 1.5: Experiment Bridge                    │
│                                                                  │
│   EXPERIMENT_PLAN.md                                             │
│         │                                                        │
│         ▼                                                        │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Claude   │────▶│ GPT-6-Astra  │────▶│ Sanity   │               │
│   │ Code     │     │ xhigh    │     │ Check    │               │
│   │ writes   │     │ reviews  │     │ (1 GPU)  │               │
│   │ code     │     │ code     │     │          │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│                                          │                       │
│                                          ▼                       │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Collect  │◀────│ Monitor  │◀────│ Deploy   │               │
│   │ results  │     │ progress │     │ to GPUs  │               │
│   │          │     │ (+ W&B)  │     │          │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│         │                                                        │
│         ▼                                                        │
│   Ready for /auto-review-loop                                    │
└─────────────────────────────────────────────────────────────────┘

Skills involved: experiment-bridge + run-experiment + monitor-experiment

💡 One-command shortcut: /experiment-bridge reads refine-logs/EXPERIMENT_PLAN.md automatically. Or point it to any plan: /experiment-bridge "my_plan.md".

⚙️ CODE_REVIEW, AUTO_DEPLOY, SANITY_FIRST, MAX_PARALLEL_RUNS are configurable — see Customization.

Workflow 2: Auto Research Loop 🔁 (sleep & wake up to results)

"Review my paper, fix what's wrong, repeat until it's good."

GPT-6-Astra reviews → identifies weaknesses → suggests experiments → Claude Code writes scripts, deploys to GPU, monitors results, rewrites the paper — all while you sleep. Just add your GPU server config to CLAUDE.md.

1. 🔍 Deep review — GPT-6-Astra xhigh reviews the current paper / claims / experiments and identifies weaknesses
2. 🩹 Fix — Claude implements the fixes (rewrites sections, adds baselines, or runs new experiments via /run-experiment); skips any experiment estimated > 4 GPU-hours and flags it for manual follow-up
3. 📊 Re-evaluate — collect results via /monitor-experiment, update paper, feed back to the reviewer
4. 🔁 Repeat — until score ≥ POSITIVE_THRESHOLD (default 6/10) or MAX_ROUNDS (default 4) is hit; if context window fills mid-loop, the workflow auto-resumes from REVIEW_STATE.json

┌─────────────────────────────────────────────────────────────┐
│                    Auto Review Loop                          │
│                                                              │
│   /research-review          /auto-review-loop                │
│   (single deep review)      (autonomous loop)                │
│         │                         │                          │
│         ▼                         ▼                          │
│   ┌──────────┐   ┌──────────┐   ┌──────────┐               │
│   │ External  │──▶│ Implement│──▶│ Monitor  │──▶ repeat     │
│   │ LLM      │   │ fixes    │   │ results  │    until       │
│   │ reviews  │   │ & run    │   │          │    score ≥ 6   │
│   └──────────┘   │ experiments│  └──────────┘               │
│                   └──────────┘                               │
│                                                              │
│   When reviewer suggests a new method direction:             │
│   /novelty-check — verify idea isn't already published       │
│                                                              │
│   Supporting skills:                                         │
│   /run-experiment    — deploy to local/remote/vast.ai GPU     │
│   /analyze-results   — interpret experiment outputs          │
│   /monitor-experiment — check progress, collect results      │
└─────────────────────────────────────────────────────────────┘

Skills involved: auto-review-loop + research-review + novelty-check + run-experiment + analyze-results + monitor-experiment

💡 One-command shortcut: /auto-review-loop "your paper topic" runs this entire workflow automatically.

What to pass as argument? A short topic or scope is enough — the skill automatically reads your project's narrative docs (NARRATIVE_REPORT.md), memory files, experiment results, and prior reviews to build the full context for GPT-6-Astra. Examples:

• /auto-review-loop "factorized gap in discrete diffusion LMs" — broad topic, skill finds everything
• /auto-review-loop "focus on Section 3-5, our CRF results are weak" — targeted scope with hints
• /auto-review-loop — also works: skill reads project files and infers the topic

🎮 Reviewer Difficulty — control how adversarial the reviewer is:

Level	What changes	Use when
medium (default)	Standard MCP review — same as before	Normal workflow
hard	+ Reviewer Memory (GPT tracks suspicions across rounds) + Debate Protocol (Claude rebuts, GPT rules)	Want tougher feedback
nightmare	+ GPT reads repo directly via codex exec (Claude can't filter what it sees) + adversarial verification	Preparing for top venue, want maximum stress test

/auto-review-loop "topic" — difficulty: nightmare    # GPT reads your code and verifies claims itself

🛡️ Key safety features:

• 🔒 MAX_ROUNDS = 4 — prevents infinite loops; stops early if score threshold is met
• ⏱️ > 4 GPU-hour experiments skipped — won't launch massive jobs; flags them for manual follow-up
• 🧠 Prefer reframing over new experiments — when both can address a weakness, chooses the cheaper path
• 🪞 No hiding weaknesses — explicit rule: "Do NOT hide weaknesses to game a positive score"
• 🔧 Fix before re-review — must actually implement fixes before resubmitting; no empty promises
• 💾 Compact recovery — persists state (REVIEW_STATE.json) after each round. If the context window fills up and auto-compacts mid-loop, the workflow reads the state file and resumes from where it left off — no human intervention needed

⚙️ MAX_ROUNDS, score threshold, and GPU limits are configurable — see Customization.

📝 Blog post: 开源 | 睡觉 Claude 自动跑实验改文

Workflow 3: Paper Writing Pipeline 📝

"Turn my research narrative into a submission-ready PDF." Requires a local LaTeX environment — see Prerequisites.

1. 📝 Narrate — write NARRATIVE_REPORT.md (claims, experiments, results, figure descriptions); see templates/NARRATIVE_REPORT_TEMPLATE.md
2. 🧭 Plan — /paper-plan builds the claims-evidence matrix + section plan
3. 📊 Figures — /paper-figure generates data-driven plots and comparison tables from JSON/CSV
4. ✍️ Write — /paper-write produces section-by-section LaTeX
5. 🔧 Compile — /paper-compile builds the PDF, fixes errors, runs the page-limit check
6. ✨ Improve — /auto-paper-improvement-loop runs 2 rounds of GPT-6-Astra content review + final format check

┌─────────────────────────────────────────────────────────────┐
│                   Paper Writing Pipeline                      │
│                                                               │
│   /paper-plan      /paper-figure     /paper-write             │
│   (outline)        (plots & tables)  (LaTeX draft)            │
│        │                │                 │                   │
│        ▼                ▼                 ▼                   │
│   ┌──────────┐    ┌──────────┐     ┌──────────┐              │
│   │ Claims-  │───▶│ Generate │────▶│ Section  │──┐           │
│   │ Evidence │    │ figures, │     │ by       │  │           │
│   │ Matrix + │    │ tables,  │     │ section  │  │           │
│   │ Section  │    │ LaTeX    │     │ LaTeX    │  │           │
│   │ Plan     │    │ includes │     │ draft    │  │           │
│   └──────────┘    └──────────┘     └──────────┘  │           │
│        │                                          │           │
│        │         /paper-compile                   │           │
│        │         (build PDF)                      │           │
│        │              │                           │           │
│        ▼              ▼                           ▼           │
│   ┌──────────────────────────────────────────────────┐       │
│   │ NARRATIVE_REPORT.md ──► PAPER_PLAN.md ──► paper/ │       │
│   │    (input)             (outline)      (LaTeX+PDF)│       │
│   └──────────────────────────────────────────────────┘       │
│                                                               │
│   Typical flow:                                               │
│   1. Write NARRATIVE_REPORT.md (from Workflow 2 results)      │
│   2. /paper-plan (claims-evidence matrix + section plan)      │
│   3. /paper-figure (comparison tables, training curves, etc.) │
│   4. /paper-write (section-by-section LaTeX generation)       │
│   5. /paper-compile (build PDF, fix errors, page check)       │
│   6. /auto-paper-improvement-loop (review ×2 + format check)  │
└─────────────────────────────────────────────────────────────┘

Skills involved: paper-plan + paper-figure + paper-write + paper-compile + auto-paper-improvement-loop + (post-acceptance) paper-poster-html + paper-slides

One-command shortcut: /paper-writing "NARRATIVE_REPORT.md" runs this entire workflow automatically.

Input: A NARRATIVE_REPORT.md describing the research: claims, experiments, results, figures. The more detailed the narrative (especially figure descriptions and quantitative results), the better the output.

Output: A paper/ directory with LaTeX source, clean .bib (only cited entries), and compiled PDF. The PDF is labelled submission-ready only when run at — effort: max | beast (or explicit — assurance: submission) and tools/verify_paper_audits.sh reports green on the three mandatory audits (proof-checker, paper-claim-audit, citation-audit); see Assurance Gate below. At the default balanced level, the output is a reviewed draft.

Key features:

• 📐 Claims-Evidence Matrix — every claim maps to evidence, every experiment supports a claim
• 📊 Auto figure generation — line plots, bar charts, comparison tables from JSON data
• 🧹 Clean bib — automated filtering removes uncited entries (948→215 lines in testing). Real BibTeX from DBLP/CrossRef instead of LLM-generated entries
• 📄 Flexible sections — 5-8 sections depending on paper type (theory papers often need 7)
• 🔍 GPT-6-Astra review — each step optionally reviewed by external LLM
• ✂️ De-AI polish — removes AI writing patterns (delve, pivotal, landscape...)
• 🎯 Page verification — pdftotext-based precise check that main body fits page limit

⚠️ Figure generation scope: /paper-figure auto-generates data-driven plots (training curves, bar charts, heatmaps) and comparison tables from JSON/CSV. For architecture diagrams and method figures: illustration: gemini (default) uses Claude→Gemini→Nano Banana Pro for publication-quality diagrams; illustration: mermaid generates Mermaid diagrams for free; illustration: false skips AI figures entirely.

Gemini API setup (for illustration: gemini): Get your API key at Google AI Studio, then set it as an environment variable: export GEMINI_API_KEY="your-key". Or add to your shell profile (~/.zshrc / ~/.bashrc). No other dependencies needed.

Tested end-to-end: Generated a 9-page ICLR 2026 theory paper (7 sections, 29 citations, 4 figures, 2 comparison tables) from a single NARRATIVE_REPORT.md — zero compilation errors, zero undefined references.

Auto Paper Improvement Loop ✨

After Workflow 3 generates the paper, /auto-paper-improvement-loop runs 2 rounds of GPT-6-Astra xhigh content review → fix → recompile, plus a final format compliance check, autonomously polishing the paper from rough draft to a reviewer-scored draft. Whether the result is tagged submission-ready is decided separately by the Phase 6 assurance gate (see Assurance Gate).

Score Progression (Real Test — ICLR 2026 theory paper):

Round	Score	Key Changes
Round 0	4/10 (content)	Baseline
Round 1	6/10 (content)	Fixed assumptions, softened claims, renamed notation
Round 2	7/10 (content)	Added synthetic validation, stronger limitations
Round 3	5→8.5/10 (format)	Removed hero fig, appendix, compressed conclusion, float spacing

Final: 8 pages main body (ICLR limit: 9), 0 overfull hbox, ICLR-compliant. +4.5 points across 3 rounds.

1. CRITICAL — Assumption-model mismatch: A boundedness assumption contradicted the model's distributional family. Replaced with a tail-compatible assumption and added formal truncation bridge.
2. CRITICAL — Theory-practice gap: Theory assumes idealized encoders, experiments use learned nonlinear encoders. Softened "validate" → "demonstrate practical relevance" and added explicit disclaimer.
3. MAJOR — Missing quantitative metrics: Added parameter count table (latent vs total) with honest accounting of system cost.
4. MAJOR — Theorem not self-contained: Added "Interpretation" paragraph listing all dependencies explicitly.
5. MAJOR — Overclaim in novelty statement: Scoped a broad "first convergence guarantee" to precise conditions under which it holds.
6. MAJOR — Notation confusion: Renamed a symbol that clashed with another key variable. Added Notation paragraph.

1. MAJOR — Missing theory-aligned experiments: Added a synthetic validation subsection directly testing the two main theoretical predictions under controlled conditions.
2. MAJOR — Overclaim softening: Replaced strong equivalence claims with appropriately hedged language across all files.
3. MAJOR — Informal theoretical argument: Formalized an informal justification into a proper proposition with explicit error bounds.
4. MINOR — Weak limitations: Expanded to explicitly list all assumptions and acknowledge missing standard evaluations.

1. Removed hero figure block (saved ~0.7 pages)
2. Compressed conclusion from 15→9 lines
3. Moved synthetic validation to Appendix A
4. Moved comparison tables to Appendix B
5. Fixed overfull hbox (85pt) with \resizebox
6. Added compact float spacing (\captionsetup, \textfloatsep)
7. Inlined centered question block in introduction
8. Tightened itemize environments

Workflow 4: Rebuttal 📝 (reply to reviewers safely)

"Reviews are in. Help me draft a safe, grounded rebuttal."

Got reviews back? /rebuttal parses them, builds a strategy, and drafts a venue-compliant response:

1. 📋 Parse — normalize reviews, validate venue rules (character limit, text-only, etc.)
2. 🔍 Atomize — split each review into issue cards (type, severity, reviewer stance)
3. 🗺️ Strategize — global themes, per-reviewer priorities, character budget, blocked claims
4. 🧪 Evidence sprint — if auto experiment: true, auto-run supplementary experiments via /experiment-bridge
5. ✍️ Draft — global opener + numbered per-reviewer responses + closing for meta-reviewer
6. 🛡️ Safety check — 6 lints: coverage, provenance, commitment, tone, consistency, limit
7. 🔬 GPT-6-Astra stress test — internal skeptical review of the draft
8. 📄 Finalize — two outputs: PASTE_READY.txt (exact character count) + REBUTTAL_DRAFT_rich.md (extended version for manual editing)
9. 🔄 Follow-up rounds — delta replies for reviewer discussions, technically escalating

┌─────────────────────────────────────────────────────────────────┐
│                   Workflow 4: Rebuttal                            │
│                                                                  │
│   Reviews arrive                                                 │
│         │                                                        │
│         ▼                                                        │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Parse &  │────▶│ Strategy │────▶│ Evidence  │               │
│   │ atomize  │     │ plan     │     │ sprint    │               │
│   │ reviews  │     │          │     │ (optional)│               │
│   └──────────┘     └──────────┘     └──────────┘               │
│                                          │                       │
│                                          ▼                       │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Finalize │◀────│ GPT-6-Astra  │◀────│ Draft    │               │
│   │ 2 versions│    │ stress   │     │ rebuttal │               │
│   │          │     │ test     │     │          │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│         │                                                        │
│         ▼                                                        │
│   PASTE_READY.txt (strict) + RICH.md (extended)                  │
│         │                                                        │
│         ▼                                                        │
│   Follow-up rounds (delta replies, per-reviewer threads)         │
└─────────────────────────────────────────────────────────────────┘

Skills involved: rebuttal

💡 Quick mode: /rebuttal — quick mode: true stops after parsing + strategy (Phase 0-3). See what reviewers want before committing to a full draft.

⚙️ VENUE, AUTO_EXPERIMENT, QUICK_MODE, MAX_STRESS_TEST_ROUNDS are configurable — see Customization.

Three safety gates — rebuttal will NOT finalize if any fails:

• 🔒 Provenance — every claim maps to paper/review/user-confirmed result. No fabrication.
• 🔒 Commitment — every promise is user-approved. No overpromising.
• 🔒 Coverage — every reviewer concern is tracked. Nothing disappears.

Workflow 5: Resubmit Pipeline 🔁 (port a paper to a new venue, text-only)

Port a polished paper from venue A → B under hard, non-overridable guardrails — no new experiments · no bib edits · no framework changes · never overwrites prior submissions — via physical isolation, a 5-layer anonymity check, soft-only audits, whitelist microedits, and a /kill-argument adversarial gate. Full flow + constraints → docs/RESUBMIT_AND_TALK.md

Workflow 6: Conference Talk Pipeline 🎤 (paper → slides → polish → audits)

/paper-talk turns an accepted paper into a talk: outline → /paper-slides (Beamer + PPTX + speaker notes + Q&A) → /slides-polish (per-page Codex visual pass) → optional conference-ready audit gate. Sister to /paper-writing / /paper-poster-html. Full flow → docs/RESUBMIT_AND_TALK.md

Workflow 7: Proof Orchestrator 🧭 (standalone theory track — attack a theorem across days, not turns)

"This proof will take a week and three tools. Keep every attempt, audit, and escalation on the record."

Hard theorems are campaigns, not chat turns. /proof-orchestrator runs proof work as a stateful, local-first pipeline — each run gets its own directory, completed runs become append-only evidence, and every new run records which prior claims were proved, conjectural, or rejected:

1. 🎯 Freeze the target — exact theorem, assumptions, quantifiers, allowed sources; new run or continuation
2. 🧱 Maintain local evidence — run directory with task.md / materials.md / stable source snapshots
3. 🧠 Attempt locally — full proof, disproof, counterexample, or diagnosis; a stall isolates the smallest hard obligation
4. 🔍 Audit correctness — every lemma, bound, and quantifier checked against assumptions; claims labeled proved / imported / conjectural / repaired / unsupported
5. ✒️ Edit for exposition — two gates: the 7-line notation scorecard (100% core-object retention, zero undefined symbols, zero collisions) and the top-down derivation-structure gate (acyclic dependency graph, no subgoal silently assuming the target — a bug-catcher in disguise: a proof that resists a clean target-first rewrite is usually hiding a gap, and circular reasoning surfaces the moment you try)
6. 📦 GPT Pro handoff — a stalled proof becomes a package: browser-prompt.md (copy-paste ready), source-manifest.md (source roles), handoff.md (upload order + return instructions)
7. 🧾 Re-audit the returned proof — format repair only, then the full correctness audit and exposition edit produce final.md

┌─────────────────────────────────────────────────────────────────┐
│              Workflow 7: Proof Orchestrator                     │
│                                                                 │
│   Theorem arrives (new run, or continuation of a prior run)     │
│         │                                                       │
│         ▼                                                       │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Freeze   │────▶│ Local    │────▶│ Correct- │               │
│   │ target + │     │ proof    │     │ ness     │               │
│   │ evidence │     │ attempt  │     │ audit    │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│                         │                │                      │
│                  LOCAL_BLOCKED     ┌──────────┐                │
│                         │          │ Notation │                │
│                         │          │ + struct │──▶ final.md    │
│                         │          │ gates    │                │
│                         │          └──────────┘                │
│                         ▼                                       │
│   ┌───────────────────────────────────────────┐                │
│   │ GPT Pro handoff package                   │                │
│   │ browser-prompt.md · source-manifest.md ·  │                │
│   │ handoff.md — you drive the browser        │                │
│   └───────────────────────────────────────────┘                │
│                         │                                       │
│                         ▼                                       │
│   gpt-pro-output.md → format repair → re-audit → gates → final │
│                                                                 │
│   Optional on request: DeepSeek adversarial audit via llm-chat  │
│   → validated locally → run-local provisional evidence          │
│                                                                 │
│   State: prompts/<run-id>/ — completed runs are append-only;    │
│   a new run reuses only audited claims                          │
└─────────────────────────────────────────────────────────────────┘

Skills involved: proof-orchestrator (+ llm-chat MCP for the optional DeepSeek branch)

⚖️ Optional DeepSeek second opinion: request it at the audit stage for a verified cross-family adversarial pass — findings are validated locally and recorded as run-local provisional evidence. An installed call-gpt-pro skill can likewise automate the GPT Pro dispatch when you ask for it on a run.

🧭 Standalone by design. Workflow 7 is theory work's own track — no Workflow 1–6 stage calls it, and /proof-checker keeps the submission gate in Workflow 3. Reach for it when a theorem outgrows single-shot /proof-writer drafting: multi-day campaigns, cross-run continuation, or when the strongest available prover lives in a browser tab.

💡 Continuation: point it at a prior run (next.md / redo.md) — it reads final.md / audit.md, reuses only audited claims, and opens a fresh run directory with full provenance.

📚 Research Wiki — Persistent Research Memory

"Stop re-deriving. Start compounding." — inspired by Karpathy's LLM Wiki

Without the wiki, ARIS is stateless — every /idea-discovery starts from scratch. With the wiki, ARIS accumulates knowledge across the entire research lifecycle: papers read, ideas tested, experiments run, claims verified or invalidated.

The key insight: failed ideas are the most valuable memory. A researcher who knows what doesn't work generates better ideas than one starting from zero.

Setup:

> /research-wiki init     # one-time, creates research-wiki/ in your project

That's it. Once initialized, the wiki works automatically.

When	What happens	Wiki action
/research-lit finds papers	Papers auto-ingested	papers/<slug>.md created, edges added, query_pack rebuilt
/idea-creator runs	Reads wiki first	Failed ideas = banlist, gaps = search seeds, papers = known prior work
/idea-creator finishes	ALL ideas written back	Both recommended AND eliminated ideas → ideas/<id>.md
/result-to-claim judges	Results written back	Experiment page created, claim status updated (supported/invalidated)
3+ ideas fail	Re-ideation suggested	"💡 Consider re-running /idea-creator — the wiki now knows what doesn't work"

Four entity types:

Entity	What it stores	Example
📄 Paper	Structured summary: thesis, method, limitations, reusable ingredients	paper:chen2025_factorized_gap
💡 Idea	Hypothesis, status (proposed/failed/succeeded), failure notes, lessons	idea:001
🧪 Experiment	Metrics, verdict, hardware, duration	exp:001
📋 Claim	Testable statement + evidence status (reported/supported/invalidated)	claim:C1

Typed relationships (stored in graph/edges.jsonl):

paper --extends--> paper              idea --inspired_by--> paper
paper --contradicts--> paper          idea --tested_by--> experiment
paper --addresses_gap--> gap          experiment --supports--> claim
paper --supersedes--> paper           experiment --invalidates--> claim

Spiral learning in action:

Round 1: read 15 papers → wiki remembers → idea A → experiment → FAIL
         wiki records: "A fails because OOM at batch>32, loss diverges"

Round 2: /idea-creator reads wiki → sees A failed → generates idea D (avoids A's trap)
         → experiment → PARTIAL SUCCESS
         wiki records: "D works on small models, fails on large"

Round 3: /idea-creator reads wiki → knows A failed + D partial → generates idea F
         (combines D's success with new approach) → experiment → SUCCESS 🎉

Subcommands:

/research-wiki init                              # initialize wiki
/research-wiki ingest "paper title" — arxiv: xxx  # manually add a paper
/research-wiki query "topic"                      # rebuild query_pack.md
/research-wiki update idea:001 — outcome: negative # update entity
/research-wiki lint                               # health check (orphans, contradictions, stale claims)
/research-wiki stats                              # overview (paper/idea/experiment/claim counts)

🔒 Safe by design: All workflow hooks are guarded by if research-wiki/ exists. No wiki = no impact. Zero dependencies (pure Python stdlib). You choose when to enable it.

---

Workflow M: Meta-Optimize 🧬 (ARIS optimizes itself)

"Analyze my usage patterns and improve your own skills."

Unlike Workflows 1–4 which optimize research artifacts (papers, code, experiments), Workflow M optimizes the harness itself — the SKILL.md instructions, default parameters, and convergence rules that govern how ARIS operates. Inspired by Meta-Harness (Lee et al., 2026).

Setup (one-time, in normal terminal):

mkdir -p .claude .aris/meta tools/meta_opt
cp Auto-claude-code-research-in-sleep/templates/claude-hooks/meta_logging.json .claude/settings.json
cp Auto-claude-code-research-in-sleep/tools/meta_opt/*.sh tools/meta_opt/
chmod +x tools/meta_opt/*.sh
claude   # hooks active immediately

Usage (after 5+ workflow runs):

> /meta-optimize                        # analyze current project
> /meta-optimize "auto-review-loop"     # focus on one skill
> /meta-optimize --global               # analyze trends across ALL projects
> /meta-optimize apply 1                # apply recommended change #1

How it works:

1. 📊 Passive logging — Claude Code hooks silently record every skill invocation, tool call, failure, parameter override, and user prompt. Events are written to both project-level (.aris/meta/events.jsonl) and global (~/.aris/meta/events.jsonl, with a "project" tag) logs. Zero user effort.
2. 🔍 Pattern analysis — /meta-optimize reads the log and identifies:
   • Parameters users override most often (bad defaults)
   • Tools that fail repeatedly in specific skills (missing error handling)
   • Review score plateaus (convergence rules too loose/tight)
   • Manual corrections users make (skill gaps)
3. 🩹 Patch proposal — generates minimal diffs to target SKILL.md files with data-backed justifications
4. 🔬 Reviewer gate — GPT-6-Astra xhigh reviews each patch: does the evidence support it? could it hurt other users?
5. ✅ User approval — only applied with explicit user consent. All changes are logged and reversible.

┌─────────────────────────────────────────────────────────────────┐
│                  Workflow M: Meta-Optimize                        │
│                                                                  │
│   Normal ARIS usage (W1-W4)                                      │
│         │ (hooks log events passively)                           │
│         ▼                                                        │
│   .aris/meta/events.jsonl                                        │
│         │                                                        │
│         ▼                                                        │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐               │
│   │ Analyze  │────▶│ Propose  │────▶│ GPT-6-Astra  │               │
│   │ patterns │     │ SKILL.md │     │ reviews  │               │
│   │          │     │ patches  │     │ patch    │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│                                          │                       │
│                                          ▼                       │
│                                    User approves?                 │
│                                     Yes → Apply                  │
│                                     No  → Skip                   │
└─────────────────────────────────────────────────────────────────┘

What gets optimized (harness components):

Component	Example
Skill prompts	Reviewer instructions, quality gates, step descriptions
Default parameters	difficulty, MAX_ROUNDS, threshold
Convergence rules	When to stop the review loop, retry counts
Error handling	Auto-debug patterns, failure recovery steps

What does NOT get optimized: research artifacts (papers, code, experiments) — that's what W1–W4 do.

Skills involved: meta-optimize

💡 This is a maintenance workflow, not part of the W1→W1.5→W2→W3→W4 research pipeline. Run it periodically, like git gc for your research harness.

---

⚡ Effort Levels

Every skill takes — effort: lite | balanced | max | beast — scaling breadth/depth (papers · ideas · pilots · rounds · seeds · audit depth) from ~0.4× to ~5–8×; balanced is the default (zero change for existing users). What never changes at any level: Codex reasoning stays at its tier floor (regular xhigh; deep audits ultra), DBLP/CrossRef citations on, reviewer independence on, experiment integrity on. 📖 Full spec + per-skill counts → effort-contract.md

Assurance Gate (effort: max | beast)

A second axis, orthogonal to effort: assurance decides whether mandatory audits are load-bearing. lite/balanced ⇒ draft (audits non-blocking — current behavior, zero change); max/beast ⇒ submission (paper-writing Phase 6 force-runs /proof-checker + /paper-claim-audit + /citation-audit in fresh threads and refuses the Final Report if tools/verify_paper_audits.sh exits non-zero). Escape hatch: — effort: beast, assurance: draft. 📖 Full spec → assurance-contract.md

🧿 Optional: GPT-5.5 Pro via Oracle

Add — reviewer: oracle-pro to any reviewer-aware skill (/proof-checker, /research-review, /experiment-audit, /rebuttal, …) to route review through GPT-5.5 Pro — strongest reasoning for deep proof / code / experiment-design critique. Default stays Codex xhigh; Oracle not installed ⇒ graceful fallback + warning (zero impact). 📖 Setup + per-skill examples → reviewer-routing.md

---

9. ⚙️ Setup

📖 New to ARIS? SETUP_GUIDE.md (中文) gives a prescriptive 6-step walkthrough for macOS local + remote Linux GPU server with Claude Code + Codex MCP — the recommended path. The section below is a quick reference; deeper GPU / customization / model-combo setup lives in the linked docs.

9.1 Prerequisites

1. Claude Code installed
2. (For review skills) Codex CLI installed and configured as MCP server:

   npm install -g @openai/codex
   claude mcp add codex -s user -- python3 "$HOME/aris_repo/mcp-servers/codex-exec/server.py"
   

   The path is mcp-servers/codex-exec/server.py inside your ARIS clone — codex-cli 0.154 removed codex mcp-server, this bridge stands in for it.
3. (For Workflow 3: paper writing) LaTeX environment with latexmk and pdfinfo:

   # macOS
   brew install --cask mactex    # or: brew install basictex
   brew install poppler          # provides pdfinfo
   
   # Ubuntu/Debian
   sudo apt install texlive-full latexmk poppler-utils
   
   # Verify
   latexmk --version && pdfinfo -v
   

   Windows (PowerShell): Install a TeX distribution using the MiKTeX Basic Installer or TeX Live for Windows. Install Poppler for Windows separately, add the directory containing pdfinfo.exe to PATH, and open a new PowerShell window. Then verify:

   latexmk --version
   pdfinfo -v
   

   If either command is not found, refresh the TeX distribution's package/path settings and check that the Poppler directory containing pdfinfo.exe is on PATH. If you only need Workflow 1 & 2 (idea discovery + auto review), LaTeX is not required.

9.2 Install Skills

💡 Recommended: project-local flat symlink install (since 2026-04-20). Each ARIS skill is symlinked individually into .claude/skills/<skill-name>, so Claude Code's slash-command discovery picks them up. A manifest at .aris/installed-skills.txt tracks what ARIS installed — uninstall and reconcile only ever touch managed entries, never your own skills.

🤖 Codex mirror route: keep Claude on install_aris.sh / smart_update.sh. For Codex-native project installs, use install_aris_codex.sh; for copied Codex installs, use smart_update_codex.sh.

🧩 Plugin route (Claude Code only): claude plugin marketplace add wanshuiyin/Auto-claude-code-research-in-sleep, then claude plugin install aris@aris, then /aris:setup once — it registers the Codex reviewer bridge that ships inside the plugin and points helper resolution at it; restart Claude Code afterwards. All skills arrive at once (no clone, no symlinks, no group selection) and are typed with the prefix: /aris:idea-discovery, /aris:paper-writing. Updates: claude plugin update aris@aris. Codex CLI reads the same repo as a plugin and gets the Codex-native mirror instead: codex plugin marketplace add wanshuiyin/Auto-claude-code-research-in-sleep, then codex plugin add aris@aris, then point helper resolution at it once — printf '%s\n' ~/.codex/plugins/cache/aris/aris/local > ~/.aris/repo (the path codex plugin list shows). Use the installers above for selective groups or the .aris/installed-skills.txt manifest.

# 1. Clone ARIS once to a stable location
git clone https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep.git ~/aris_repo

# 2. For each project that uses ARIS, attach via symlinks:
cd ~/your-paper-project
bash ~/aris_repo/tools/install_aris.sh
# → creates one symlink per skill: .claude/skills/<skill> → ~/aris_repo/skills/<skill>
# → writes manifest .aris/installed-skills.txt (tracks every entry ARIS installed)
# → updates managed CLAUDE.md ARIS block (best-effort, compare-and-swap)
# → re-runnable: rerun anytime to reconcile new/removed upstream skills

# 3. To update existing skills' content for ALL attached projects:
cd ~/aris_repo && git pull   # symlinks resolve to live upstream — content updates automatically

# 3a. To pick up newly added or removed upstream skills, rerun the installer:
bash ~/aris_repo/tools/install_aris.sh ~/your-paper-project   # adds new symlinks, removes broken ones

# Install only what you need (#366 selective install; a bare TTY run opens a checkbox picker):
bash ~/aris_repo/tools/install_aris.sh --list-groups                  # show the 10-group catalog
bash ~/aris_repo/tools/install_aris.sh --groups paper-core,lit-search # install by group
bash ~/aris_repo/tools/install_aris.sh --skills paper-writing         # by skill; hard pipeline deps auto-included
bash ~/aris_repo/tools/install_aris.sh --exclude patent-pipeline      # opt out (declined; never re-asked on update)
# On update, NEW upstream skills need per-skill confirmation; --add-new accepts all / --skip-new skips all

# Other useful flags:
bash ~/aris_repo/tools/install_aris.sh --dry-run        # show plan, no changes
bash ~/aris_repo/tools/install_aris.sh --uninstall      # remove only managed symlinks (per manifest)
bash ~/aris_repo/tools/install_aris.sh --from-old       # migrate from old nested .claude/skills/aris/

# Windows (PowerShell, no WSL required; creates flat per-skill junctions):
.\tools\install_aris.ps1 C:\path\to\your-paper-project -Platform claude
.\tools\install_aris.ps1 C:\path\to\your-codex-project -Platform codex

Why "git pull" alone isn't enough for new/removed skills: the flat layout uses one symlink per skill, so upstream additions/deletions don't propagate until the installer is re-run. The trade-off bought us Claude Code's automatic slash-command discovery (which only scans one directory level deep).

If you previously installed via install_aris.sh (which created .claude/skills/aris/ as a single nested symlink) or via smart_update.sh --target-subdir .claude/skills/aris, your slash commands probably weren't being auto-discovered by Claude Code. Migrate to the flat layout:

# Symlink-style legacy install:
bash ~/aris_repo/tools/install_aris.sh ~/your-project --from-old

# Copy-style legacy install (with possible local edits — chose strategy explicitly):
bash ~/aris_repo/tools/install_aris.sh ~/your-project --from-old --migrate-copy keep-user
#   → keeps your nested .claude/skills/aris/ copy intact alongside the new flat install
bash ~/aris_repo/tools/install_aris.sh ~/your-project --from-old --migrate-copy prefer-upstream
#   → archives nested copy to .aris/legacy-copy-backup-<timestamp>/, then flattens

Project-local copy (no symlinks, useful for per-project skill edits):

mkdir -p ~/your-project/.claude/skills
bash ~/aris_repo/tools/smart_update.sh --project ~/your-project --apply
# Default --target-subdir is .claude/skills (flat), which is what Claude Code expects.
# (The old --target-subdir .claude/skills/aris is now deprecated — see migration block above.)

Global install (one copy in your home dir, available to every project):

mkdir -p ~/.claude/skills
cp -r ~/aris_repo/skills/* ~/.claude/skills/
# Update with: bash tools/smart_update.sh --apply

Global install increases the risk of skill name collisions with other globally-installed packs. Use only if you don't mix ARIS with Superpowers / OpenHands / etc. — otherwise prefer the project-local install above.

💡 New Claude Code versions may not auto-create ~/.claude/skills/. If using global install, create it first: mkdir -p ~/.claude/skills/. The symlink installer handles directory creation automatically.

codex-plugin-cc provides additional Codex capabilities that ARIS auto-detects when installed:

# In Claude Code:
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

Where ARIS uses the plugin:

Skill	Workflow	What it does
/codex:review	Workflow 1.5	Review experiment code before GPU deployment
/codex:adversarial-review	Workflow 1.5	Adversarial code review (find edge cases, bugs)
/codex:rescue	Workflow 1.5 + 3	Auto-debug rescue — when experiment or LaTeX compilation fails after 2 attempts, Codex independently diagnoses the root cause before the next retry

All plugin features are optional — if not installed, ARIS falls back to Claude's own diagnosis. The plugin just adds a second pair of eyes.

Note: ARIS's core cross-model review (paper scoring, idea evaluation, rebuttal stress test) still uses Codex MCP, which allows custom prompts. The plugin cannot replace this.

9.3 Update Skills

cd Auto-claude-code-research-in-sleep
git pull

# 🧠 Smart update (recommended) — analyzes what's safe to update
bash tools/smart_update.sh          # dry-run: shows what would change
bash tools/smart_update.sh --apply  # apply: updates safe ones; NEW upstream skills prompt
                                     # one-by-one on a TTY, or use --add-new / --skip-new

# Manual options (if you prefer):
# cp -r skills/* ~/.claude/skills/       # Option A: overwrite all
# cp -rn skills/* ~/.claude/skills/      # Option B: only add new, keep yours
# cp -r skills/experiment-bridge ~/.claude/skills/  # Option C: specific skill

💡 Smart update compares your local skills with upstream, detects personal customizations (server paths, API keys, etc.), and only updates skills that are safe to replace. Skills with your personal info are flagged for manual review.

9.4 Usage

# Workflow 1: Idea Discovery
> /idea-discovery "your research direction"          # full pipeline
> /research-lit "topic"                              # just literature survey (all sources)
> /research-lit "topic" — sources: zotero, web        # mix and match sources
> /research-lit "topic" — sources: deepxiv            # DeepXiv-only progressive retrieval
> /research-lit "topic" — sources: exa                # Exa AI-powered web search with content extraction
> /research-lit "topic" — arxiv download: true         # also download top arXiv PDFs
> /arxiv "discrete diffusion" — download               # standalone arXiv search + download
> /idea-creator "topic"                              # just brainstorm

# Workflow 2: Auto Research Loop
> /auto-review-loop "your paper topic"               # review → fix → repeat
> /research-review "your paper"                      # single deep review

# Workflow 3: Paper Writing
> /paper-writing "NARRATIVE_REPORT.md"               # full pipeline
> /paper-plan "NARRATIVE_REPORT.md"                  # just outline
> /paper-compile "paper/"                            # just compile

# Full Pipeline
> /research-pipeline "your research direction"       # Workflow 1 → 2 → 3 end-to-end

# Supporting Skills
> /run-experiment train.py --lr 1e-4 --epochs 100
> /analyze-results figures/*.json
> /monitor-experiment server5

9.5 🌙 Auto-Allow for Overnight Runs (Optional)

To run the auto-review loop without clicking permission prompts, add to .claude/settings.local.json:

{
  "permissions": {
    "allow": [
      "mcp__codex__codex",
      "mcp__codex__codex-reply",
      "Write",
      "Edit",
      "Skill(auto-review-loop)"
    ]
  }
}

🖥️ GPU for Auto-Experiments (Optional)

When the reviewer says "run an ablation", Claude Code writes the script and runs it on your GPU — you just declare your server in CLAUDE.md. Three modes (Remote SSH · Local GPU · Vast.ai on-demand): config snippets + setup → docs/GPU_SETUP.md (Vast.ai deep-dive → Vast.ai guide). No GPU? Review/rewrite skills still work; experiment fixes are flagged for manual follow-up.

🔌 Integrations (Optional)

Plug your library / vault / notifications into ARIS — each auto-skips silently if unconfigured:

• Zotero — collections + annotations + BibTeX in /research-lit (before web search).
• Obsidian + arXiv — search your vault notes; arXiv is built-in, no setup.
• Feishu / Lark — mobile push + interactive approve/reject for overnight runs.

10. 🎛️ Customization

Skills are plain Markdown — fork and tune them. Per-skill environment variables (GPU target, code review, reviewer routing, human checkpoints, paper-writing knobs) and parameter pass-through live in docs/CUSTOMIZATION.md.

Reviewer quota tight? The defaults are chosen for quality and stay as they are: skills start from natural language, and every review goes to the cross-model reviewer at its full tier. If a casual sentence starting a skill costs you quota, these are yours to opt into:

Option	Saves	Costs
Paste the paragraph below into your project's CLAUDE.md	Skills starting from a sentence that merely resembles a trigger	You name the skill to start it. It is guidance to the model, not a guarantee
— reviewer: manual	Every reviewer call	You paste the review in yourself, so no unattended overnight run
— effort: lite	Papers read, ideas generated, rounds run	Nothing on the reviewer: its tier is never lowered

Start ARIS skills or external reviewers only when I name an ARIS skill or explicitly
request an ARIS workflow. That request includes its child skills and reviewers;
continue under AUTO_PROCEED without asking for confirmation.

11. 🔀 Alternative Model Combinations

No Claude / OpenAI API? Swap in other providers — same cross-model architecture. ARIS ships 10 alternative routes (Z.ai GLM, Alibaba Kimi/Qwen/MiniMax, free DeepSeek-V3.1 via ModelScope, OpenRouter as a pin-one-of-many reviewer backend, Codex-as-executor with Claude/Gemini reviewers, Google Antigravity). Full routing table + per-route setup in docs/MODEL_COMBINATIONS.md.

12. 💬 Community

Domain-specific skills welcome! The core skills cover general research workflows, but every field has its own tools and patterns. We welcome PRs that add new skills for your domain — EDA, bioinformatics, robotics, HPC, or anything else. Just add a skills/your-skill/SKILL.md and open a PR. See dse-loop for an example.

Join the WeChat group for discussion on Claude Code + AI-driven research workflows:

13. 📖 Citation

If you use ARIS in your research, please cite:

@article{yang2026aris,
  title={ARIS: Autonomous Research via Adversarial Multi-Agent Collaboration},
  author={Yang, Ruofeng and Li, Yongcan and Li, Shuai},
  journal={arXiv preprint arXiv:2605.03042},
  year={2026}
}

14. ⭐ Star History

15. 🙏 Acknowledgements

Inspired by — 🧪 AI Scientist (Sakana) · 📖 AutoResearch (Karpathy) · 🔭 FARS (Analemma) · 🎨 PaperBanana (PKU).

Core infra — Claude Code (execution backbone) · Codex CLI (cross-model review via MCP).

Integrations — Zotero (guide): zotero-mcp, Zotero. Obsidian (guide): mcpvault, obsidian-skills (by Obsidian CEO Steph Ango). Feishu/Lark (guide): feishu-claude-code, clawdbot-feishu, cc-connect, lark-openapi-mcp.

Paper-writing inspiration — claude-scholar · Research-Paper-Writing-Skills · baoyu-skills. Community — awesome-agent-skills (featured).

Platform adaptation — 🤖 @Falling-Flower (Codex CLI adaptation via spawn_agent) · 🔧 @No-518 (Codex skill maintenance) · 🖱️ @YecanLee (Cursor guide + local GPU docs) · 🏆 @DefanXue & @Monglitay (first ARIS community paper, CS conference 8/10).

Architecture & vision — 💡 @JingxuanKang: beyond code (training-check, result-to-claim, ablation-planner, watchdog, templates, session recovery), deeply shaped ARIS through discussions on compact mode, workflow state management, and the vision of autonomous research — many of today's core features (structured project files, context-aware session recovery) grew out of these conversations.

16. License

MIT