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

💡 Use ARIS in Claude Code / Cursor / Trae as a skill-based workflow, or get the full experience with the standalone CLI — enjoy any way you like!

🤖 AI agents: Read AGENT_GUIDE.md instead — structured for LLM consumption, not human browsing.

🔥 ARIS-Code CLI — 独立安装版 · English | ⬇️ Download

📰 ARIS-Code v0.4.4 (2026-04-20) — Setup UX + reviewer routing fixes (resolves #158, #162) | /setup no longer forces Bearer for Anthropic + custom URL (fixes ModelScope / code.newcli.com etc.) | Provider-aware proxy URL hints | Stale state no longer leaks across provider switches | LlmReview smart fallback

Previous versions

v0.4.3 (2026-04-17) — Third-party Anthropic-compat proxy support (Bedrock etc.) | Skip beta flags that proxies reject | Propagate custom base URL for anthropic provider | Credit @screw-44

v0.4.2 (2026-04-17) — Auto-compaction corruption fix | Compaction summary preserved on OpenAI-compat executors | Shell-provided API keys no longer erased on launch

v0.4.1 (2026-04-15) — Plan mode (/plan) | Cooperative Ctrl+C interrupt | Auto-retry (429/5xx/network) | Research Wiki 📚 (persistent knowledge base) | Self-Evolution 🧬 (/meta-optimize) | Local models (LM Studio/Ollama) | 62 skills synced

v0.3.11 (2026-04-13) — Reviewer Anthropic-compatible mode (Claude via proxy)

v0.3.9 (2026-04-11) — Proxy/custom base URL (CCSwitch) | Local models (LM Studio/Ollama) | Windows (experimental)

v0.3.5 (2026-04-08) — Research Wiki (persistent papers/ideas/experiments/claims + relationship graph) | Meta-Optimize self-evolution (analyze logs → propose SKILL.md patches)

v0.3.0 (2026-04-03) — Multi-file memory index | Rich task system (TodoWrite) | /plan | Security hardening

v0.2.2 (2026-04-03) — /plan step-by-step planning | /tasks persistent tracking

v0.2.1 (2026-04-03) — Persistent Memory | Kimi K2.5 multi-turn fix | CJK cursor fix

v0.2.0 (2026-04-02) — Open source | Kimi + MiniMax + GLM support | Smart LlmReview routing | CI/CD

v0.1.0 (2026-04-02) — Initial release | Multi-executor & reviewer | 42 bundled skills

中文版 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 — zero dependencies, zero lock-in. The entire system 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, Windsurf, or your own agent and the workflows still work. Fork it, rewrite it, adapt it to your stack.

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

· · · · 💬 Join Community ·

Custom Claude Code skills for autonomous ML research workflows. These skills orchestrate cross-model collaboration — Claude Code drives the research while an external LLM (via Codex MCP) acts as a critical reviewer. 🔀 Also supports alternative model combinations (Kimi, LongCat, DeepSeek, etc.) — no Claude or OpenAI API required. For example, MiniMax-M2.7 + GLM-5 or GLM-5 + MiniMax-M2.7. 🤖 Codex CLI native — full skill set also available for OpenAI Codex. 🖱️ Cursor — works in Cursor too. 🖥️ Trae — ByteDance AI IDE. 🚀 Antigravity — Google's agent-first IDE. 🆓 Free tier via ModelScope — zero cost, zero lock-in.

💭 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-5.4 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.4 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 →

🎯 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."

🔥 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).

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

/paper-slides "paper/"     # → Beamer PDF + PPTX + speaker notes + Q&A prep
/paper-poster "paper/"     # → A0/A1 poster PDF + editable PPTX + SVG

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

🏆 Community Submissions Built with ARIS

Built with ARIS — from idea to submission. AI-review scores are community-reported signals from simulated/third-party review tools, not official peer-review or acceptance results. Because ARIS explicitly iterates against AI reviewers, higher AI-review scores are expected and should be read as stress-test feedback; human reviewers may bring newer perspectives, venue taste, and concerns not captured by those systems. Full details + review screenshots →

📢 What's New

• 2026-05-06 — 🎤 /paper-talk workflow + /slides-polish skill — end-to-end conference talk pipeline. /paper-talk orchestrates paper → slide outline → Beamer + PPTX → per-page polish → assurance audits → final report (sister to /paper-writing, /paper-poster); composes /paper-slides, /slides-polish, plus /paper-claim-audit + /citation-audit when assurance: conference-ready. /slides-polish is the post-generation visual pass: per-page Codex review against a reference PDF + a fix-pattern catalog (PPTX font scaling 1.5-1.8× for projector-readable size, text-frame resize after font bump, banner-as-tcolorbox, italic style leak guard, em-dash spacing, Chinese EA font hint via PingFang SC, anonymity placeholder discipline). Assurance ladder draft / polished (default) / conference-ready is independent from the effort axis; effort: lite, assurance: conference-ready is legal and means "fast pipeline, every audit must emit verdict before final". Phase 4 staging adapter materializes slide text + speaker notes + talk script as a synthetic paper directory (.aris/paper-talk/audit-input/sections/*.tex + symlinked .bib / results/ / figures/) so the existing audits run with their paper-shaped contracts and emit 6-state JSON verdicts per shared-references/assurance-contract.md.
• 2026-05-05 — 🔁 /resubmit-pipeline — Workflow 5: text-only resubmit across venues (#208). Port a polished paper from one venue to another under hard constraints (no new experiments, no bib edits, no framework changes, never overwrite prior submissions). 5 phases: physical isolation → 5-layer anonymity check → audits (proof / claim / citation --soft-only) → microedits via /auto-paper-improvement-loop --edit-whitelist with per-round diff gate → adversarial gate via /kill-argument → final compile + Overleaf push via /overleaf-sync. Two prerequisite SKILL upgrades shipped in the same PR: /auto-paper-improvement-loop --edit-whitelist <path> (YAML schema with allowed/forbidden paths + forbidden_operations like new_cite / new_theorem_env / numerical_claim, forbidden_deletions, requires_user_approval_for, max_edits_per_round) and /citation-audit --soft-only (translates KEEP/FIX/REPLACE/REMOVE verdicts to text-rewrite proposals when bib is frozen; hallucinated citations get drop_cite_in_body_only action). Master RESUBMIT_REPORT.json ledger per shared-references/assurance-contract.md; 7-verdict failure mode table including USER_DECISION runtime state.
• 2026-05-05 — 🗡 /kill-argument — adversarial Attack-Adjudication review for theory papers (#206). Two fresh codex 5.5 + xhigh threads: Thread 1 writes the strongest 200-word rejection memo a senior area chair would produce; Thread 2 (independent adjudicator, NOT defender) reads the current paper and classifies each rejection point as answered_by_current_text / partially_answered / still_unresolved with file:line evidence. Output: KILL_ARGUMENT.{md,json}, detect-only. Integrated as Phase 5.6 of /paper-writing (between claim-audit and citation-audit) and as the canonical implementation called from /auto-paper-improvement-loop Step 5.5 — replaces inline prompt in both places. Mandatory at assurance: submission for theory-heavy / scope-heavy papers; emits NOT_APPLICABLE for empirical papers without scope claims. Audit JSON is verify_paper_audits.sh-compatible (full schema per shared-references/assurance-contract.md, 6-state verdict). Catches the failure mode score-based reviews miss: when every local component is correct (numbers match, cites resolve, theorems prove) but the paper still oversells what it actually establishes.
• 2026-05-04 — 🪲 /research-wiki and 8 caller skills now resolve helper via fallback chain (#204). Bug: after bash tools/install_aris.sh the helper lives at .aris/tools/research_wiki.py (symlink), but skills hard-coded tools/research_wiki.py and silently failed when invoked — research-wiki/ stayed empty across full W1 runs. Fix: 3-layer chain (.aris/tools/ → tools/ → $ARIS_REPO/tools/) codified in shared-references/wiki-helper-resolution.md. The manual-copy workaround at <project>/tools/research_wiki.py is layer 2, so users who cp-installed the helper as a temporary fix continue to work. ⚠️ Existing users: rerun bash tools/install_aris.sh once — also picks up a separate Python 3.9 ImportError fix in the helper.
• 2026-05-03 — 🎨 Opt-in — style-ref: <source> for writer-side skills (#202). /paper-{plan,write,writing,illustration,poster,slides}, /grant-proposal, and /auto-paper-improvement-loop accept an optional — style-ref: <source> argument that mimics a reference paper's structural style (section ordering, theorem/figure density, sentence cadence, citation style) without copying its prose, claims, or terminology. Sources: local .tex dir/file, local PDF, arXiv id (2501.12345 or arxiv:2501.12345), HTTP/HTTPS URL. Overleaf URLs/IDs are rejected — clone via /overleaf-sync setup <id> first. Default OFF; existing behavior unchanged when the flag is absent. Reviewer / auditor sub-skills (/proof-checker, /paper-claim-audit, /citation-audit, the improvement-loop reviewer) never see the style ref — cross-model review independence preserved. ⚠️ Existing ARIS users: the helper ships at tools/extract_paper_style.py, distributed via the .aris/tools symlink (install_aris.sh Phase 0, added in #192). Re-run bash tools/install_aris.sh once to refresh the symlink and pick up the helper. Manual fallback: cp <ARIS-repo>/tools/extract_paper_style.py <your-project>/tools/. Without either, the writer skill aborts with a clear error pointing here.
• 2026-05-02 — 🪨 Community spotlight: rosetta by @SyntaxSmith. 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 ARIS users invoking — reviewer: oracle-pro — same target capability (Pro-tier reviewer), different mechanics. Indexed under Awesome Community Skills & Extensions. 🌟 if you're using it!
• 2026-05-02 — 💎🧿 Model & MCP routing updates. (a) /gemini-search default bumped to gemini-3-pro-preview (strongest Gemini, out-of-box). ⚠️ Action required: requires gemini-cli v0.40+ (run gemini --version; upgrade with npm i -g @google/gemini-cli if older). Legacy override: /gemini-search "topic" — model: gemini-2.5-pro. Other overrides: gemini-3-flash-preview (faster), auto-gemini-3 (load-routed). (b) /idea-discovery Phase 1 now includes Gemini in its literature survey by default (#199) — auto-injects — sources: all, gemini into /research-lit unless the user passed an explicit — sources:; graceful skip if gemini-cli not installed. (c) Oracle MCP upstream PR queue (steipete/oracle/pulls) is the first triage stop when invoking — reviewer: oracle-pro (especially o3-deep-research / gpt-5.5-pro) — ARIS does not vendor Oracle MCP; check upstream first if behavior surprises you (reviewer-routing.md)
• 2026-05-02 — 🛠️🔗 Tools-infrastructure migration started. (a) install_aris.sh creates optional .aris/tools symlink (#192, closes #174) — Phase 0 of the 4-step tools-stability plan (#174 → #176 → #177 → #178); idempotent, zero impact until rerun. (b) /experiment-queue orchestration paths repaired (#193) — first real user of the symlink; 7 cascading bugs fixed via 3 rounds of Codex MCP gpt-5.5 xhigh audit. Pure prose + docstring; queue_manager.py logic untouched. Windows install_aris.ps1 parallel update tracked as follow-up
• 2026-05-02 — 🔬 Three new opt-in audit flags via fast-path delegated-agent workflow (#187, #188, #189). /citation-audit --uncited surfaces bib entries with no \cite{} reference (detect-only). /proof-checker --deep-fix adds a repair-grade plan to the Phase 1 reviewer prompt (corrected statement / patch plan / closure tests + Schur/quadratic-form algebra sanity). /proof-checker --restatement-check adds Phase 3.6 cross-location theorem drift detection (6 drift signatures). Zero behavior change when flags unset. Plus doc PRs #190 (thread-policy) + #191 (auto-loop xref). Delegated-agent + maintainer-fixup pattern; Codex MCP gpt-5.5 xhigh review caught 6+ blockers
• 2026-05-01 — 🔍 Gemini + OpenAlex literature sources for /research-lit (#175, community contribution by @stdAri). Two opt-in sources: /gemini-search (AI-driven discovery via jamubc/gemini-mcp-tool MCP) and /openalex (250M+ work open citation graph, no API key). Triggered via — sources: gemini or — sources: openalex; zero behavior change when default all (both excluded). Maintainer fixups: corrected @google/gemini-cli npm name; added try/except ImportError + bash preflight for graceful OpenAlex skip when requests missing
• 2026-04-30 — 📝 /rebuttal per-reviewer thread mode + transferable patterns (SKILL.md). Adds VENUE_MODE (single_document | per_reviewer_thread) for OpenReview-style venues, reviewer_priority: pivotal routing, structural_distinction response mode, 5 reviewer-defensive heuristics, 2 Phase 5 lints, and severity-scaled stress rounds. Default VENUE_MODE = single_document keeps ICML-style behavior — zero change for existing users. Three rounds of cross-model review before/after merge
• 2026-04-30 — 🪞 Codex skill mirror rebuilt + dedicated install/update chain (#179, community contribution by @No-518). skills/skills-codex/ now mirrors all 67 mainline skills; replaces mcp__codex__codex reviewer path with Codex-native spawn_agent + send_input. New tools/install_aris_codex.sh + tools/smart_update_codex.sh handle project-local symlinks with manifest tracking. Anti-drift: tests/test_codex_skill_mirror.py + tests/test_codex_install_update.py (26 failure paths). Open discussion in #184
• 2026-04-24 — 🎨 /paper-illustration-image2 — Codex-native image generation as Phase 2b illustration backend (#166, community contribution by @kbr19-thu 清华). Uses ChatGPT Plus/Pro quota via local Codex app-server MCP bridge — no GEMINI_API_KEY required. Triggered by /paper-writing — illustration: codex-image2; default stays figurespec (zero behavior change). Async-only API, sandboxed writes to figures/ai_generated/, integration-contract-compliant helper. Marked experimental (Codex debug app-server is unstable upstream)
• 2026-04-21 — 📚 Research Wiki ingest actually works now (research_wiki.py, /research-wiki). Fixes user-reported bug where /research-wiki init left papers/ empty forever (ingest subcommand had no implementation; paper-reading skills had no wiki hook). New canonical python3 tools/research_wiki.py ingest_paper helper owns slugging / metadata fetch / dedup / page render; all 6 paper-reading skills wired to it. Manual backfill via sync --arxiv-ids or sync --from-file. Ships with integration-contract.md formalizing the six-component pattern every cross-skill integration must follow
• 2026-04-21 — 🛡️ Assurance Gate: — effort: beast | max now really runs mandatory audits (assurance-contract.md, tools/verify_paper_audits.sh). Fixes silent-skip of /proof-checker / /paper-claim-audit / /citation-audit at high effort. New assurance axis (draft | submission) independent from effort: lite / balanced → draft (zero behavior change), max / beast → submission. At submission the 3 audits emit a JSON artifact with 6-state verdict; paper-writing Phase 6 runs the external verifier as source of truth (non-zero exit blocks Final Report). SHA256 input hashing catches stale audits. Escape hatch: — effort: beast, assurance: draft

🚀 Quick Start

# 1. Install skills
git clone https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep.git
mkdir -p ~/.claude/skills/    # create if it doesn't exist (new Claude Code versions)
cp -r Auto-claude-code-research-in-sleep/skills/* ~/.claude/skills/

# 1b. Update skills (when upstream has new versions)
cd Auto-claude-code-research-in-sleep && git pull
bash tools/smart_update.sh          # dry-run: shows what's new/changed/safe
bash tools/smart_update.sh --apply  # apply: adds new + updates safe ones

# 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. Set up Codex MCP (for review skills)
npm install -g @openai/codex
codex setup                    # set model to gpt-5.4 when prompted
claude mcp add codex -s user -- codex mcp-server

# 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
> /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

📚 Research Wiki (optional): 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.

See Research Wiki for the full guide.

🧬 Meta-optimization (optional): 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. See Workflow M for details.

📝 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.

🗑️ 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/{}

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

Parameter	Default	What it does
AUTO_PROCEED	true	Auto-continue at idea selection gate. Set false to manually pick which idea to pursue 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, or all. Note: semantic-scholar, deepxiv, and exa 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-5.4 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 false (skip)
venue	ICLR	Target venue: ICLR, NeurIPS, ICML, CVPR, ACL, AAAI, ACM. Determines LaTeX style file and page limit
base repo	false	GitHub repo URL to clone as base codebase (e.g., — base repo: https://github.com/org/project). No code? Build on top of an open-source project
gpu	local	GPU target: local (default), remote (SSH server), or vast (rent on-demand from Vast.ai — auto-provision, auto-destroy)
compact	false	Generate compact summary files (IDEA_CANDIDATES.md, findings.md, EXPERIMENT_LOG.md) for short-context models and session recovery
ref paper	false	Reference paper to build on (PDF path or arXiv URL). Summarized first, then ideas extend/improve it. Combine with base repo for paper+code workflows
effort	balanced	Work intensity: lite (0.4x tokens), balanced (default), max (2.5x), beast (5-8x). Controls breadth/depth/iterations. Codex reasoning always xhigh. See Effort Levels
reviewer	codex	Reviewer backend: codex (GPT-5.4 xhigh, default), oracle-pro (GPT-5.4 Pro via Oracle — strongest reasoning). See Setup →
difficulty	medium	Reviewer adversarial level: medium (default), hard (+ memory + debate), nightmare (+ GPT reads repo via codex exec)

/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" — 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.4 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

Important: Codex MCP uses the model from ~/.codex/config.toml, not from skill files. Make sure it says model = "gpt-5.4" (recommended). Other options: gpt-5.3-codex, gpt-5.2-codex, o3. Run codex setup or edit the file directly.

Want Codex to execute but Claude Code to review? See docs/CODEX_CLAUDE_REVIEW_GUIDE.md. That path installs the base skills/skills-codex/*, then overlays skills/skills-codex-claude-review/*, and routes review-heavy skills through the local claude-review MCP bridge.

Want Codex to execute but Gemini to review locally? See docs/CODEX_GEMINI_REVIEW_GUIDE.md and CN. That path installs the base skills/skills-codex/*, then overlays skills/skills-codex-gemini-review/*, and routes the reviewer-aware predefined skills through the local gemini-review MCP bridge using direct Gemini API by default.

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.

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

🧠 Update skills later? Smart update analyzes what's safe:

cd Auto-claude-code-research-in-sleep
git pull
bash tools/smart_update.sh          # dry-run: shows what's new/changed/safe
bash tools/smart_update.sh --apply  # apply: adds new + updates safe ones

Compares 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.

✨ Features

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

• 🔍 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, GPT-5.4 xhigh reviews. Adversarial, not self-play. Optional upgrade: — reviewer: oracle-pro for GPT-5.4 Pro (strongest reasoning) via Oracle

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

• 🖥️ Review-driven experiments — when GPT-5.4 says "run an ablation", Claude Code automatically writes the script, rsyncs to your GPU server, launches in screen, collects results, and folds them back into the paper. Just configure your server in CLAUDE.md (setup guide). No GPU? Use gpu: vast to rent one from Vast.ai on demand

• 🔀 Flexible models — default Claude × GPT-5.4, also supports GLM, MiniMax, Kimi, LongCat, DeepSeek, etc. — no Claude or OpenAI API required

• 🛑 Human-in-the-loop — configurable checkpoints at key decisions. AUTO_PROCEED=true for full autopilot, false to approve each step

• 📱 Feishu/Lark notifications — three modes: off (default, strongly recommended for most users), push-only (webhook, mobile alerts), interactive (approve/reject from Feishu). Zero impact when unconfigured

  Preview: Push cards (group) & Interactive chat (private)

  Push Only — group chat cards (experiment done, checkpoint, error, pipeline complete):

  

  Interactive — private chat with Claude Code (approve/reject, custom instructions):

  

• 📚 Research Wiki — persistent knowledge base that accumulates papers, ideas, experiments, and claims across the research lifecycle. Failed ideas become anti-repetition memory. ARIS learns from its mistakes and gets smarter with every run. Inspired by Karpathy's LLM Wiki

• 🧩 Extensible — domain-specific skills welcome! Add a SKILL.md and open a PR. See community skills like dse-loop (architecture/EDA)

📈 Score Progression (Real Run)

A real overnight 4-round run on an ML research project, from borderline reject to submission-ready:

The loop autonomously ran 20+ GPU experiments, rewrote the paper's narrative framing, and killed claims that didn't hold up — all without human intervention.

🏆 Community Showcase — Papers Built with ARIS

Real projects where the ARIS pipeline was used end-to-end to produce submitted manuscripts. This section does not claim official acceptance unless a row explicitly says so: ratings and quoted verdicts are AI/third-party review signals from tools such as CSPaper and Stanford Agentic Reviewer, not venue decisions. One important caveat: ARIS is designed to optimize through AI-review loops, so elevated AI-review scores are a normal consequence of the workflow rather than independent proof of acceptance. Human reviewers can still bring updated literature knowledge, community context, venue-specific taste, and objections that an AI reviewer did not model. If you've used ARIS to complete a paper, we'd love to feature it here — open an issue or PR!

Reviewer screenshots

Papers built with ARIS — from idea to submission. Know more? Let us know!

🧩 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 (13): research-refine · experiment-plan · grant-proposal · paper-poster · paper-slides · mermaid-diagram · proof-writer · comm-lit-review · dse-loop · idea-discovery-robot · formula-derivation · paper-illustration · writing-systems-papers

🌐 External Projects & Docs (12): rosetta · open-source-hardening-skills · CitationClaw · auto-hparam-tuning · paper-to-course · Antigravity Adaptation Guide · OpenClaw Adaptation Guide · Cursor Adaptation Guide · Codex+Claude Review Bridge · Trae Adaptation Guide · paper-illustration · MiniMax-AI/cli

🙌 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!

🔄 Workflows

These skills compose into a full research lifecycle. The four workflows 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 to acceptance
• 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)

📝 Blog post: 梦中科研全流程开源

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-5.4 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-5.4 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: Each phase presents results and waits for your feedback. Not happy? Tell it what's missing — it refines the prompt and regenerates. Trust the defaults? It auto-proceeds with the top-ranked option. You decide how hands-on to be.

⚙️ 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-5.4 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-5.4  │────▶│ 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-5.4 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.

┌─────────────────────────────────────────────────────────────┐
│                    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-5.4. 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:

/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.

┌─────────────────────────────────────────────────────────────┐
│                   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 + 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. See templates/NARRATIVE_REPORT_TEMPLATE.md for a complete example.

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-5.4 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-5.4 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):

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

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-5.4 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-5.4  │◀────│ 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.

📚 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:

Four entity types:

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-5.4 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-5.4  │               │
│   │ patterns │     │ SKILL.md │     │ reviews  │               │
│   │          │     │ patches  │     │ patch    │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│                                          │                       │
│                                          ▼                       │
│                                    User approves?                 │
│                                     Yes → Apply                  │
│                                     No  → Skip                   │
└─────────────────────────────────────────────────────────────────┘

What gets optimized (harness components):

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

"How hard should ARIS work?" — Every skill accepts — effort: lite | balanced | max | beast.

What NEVER changes regardless of effort:

• Codex reasoning: always xhigh (reviewer quality is non-negotiable)
• DBLP/CrossRef citations: always on
• Reviewer independence: always on
• Experiment integrity: always on

# Every skill accepts effort independently
/research-lit "topic" — effort: beast              # 40-50 papers, 15+ queries
/idea-creator "direction" — effort: lite           # 4-6 ideas, quick filter
/auto-review-loop — effort: max                    # 6 rounds, 4-6 fixes/round

# Mix with specific overrides
/auto-review-loop — effort: beast, review_rounds: 3  # beast everything, but cap at 3 rounds

# Full pipeline
/research-pipeline "your topic" — effort: beast    # top-venue sprint mode

📖 Full specification: shared-references/effort-contract.md

Assurance Gate (effort: max | beast)

ARIS has two independent axes: effort controls how much work is done (breadth/depth), assurance controls whether mandatory audits are load-bearing. Default mapping:

What this fixes: previously, — effort: beast did not actually guarantee the three mandatory audits ran — the content detectors could silent-skip, so beast-mode papers could ship without proof verification or citation checks. The assurance axis makes audit enforcement externally verifiable via tools/verify_paper_audits.sh (the verifier's exit code is the source of truth, not the executor's self-report).

Backwards compatibility: users on the default balanced level see zero change. Only users who opt up to max / beast, or who explicitly pass — assurance: submission, see the new gate.

Escape hatch: — effort: beast, assurance: draft gets the old "depth-only, no audit gate" behavior back. Legal but discouraged for actual submissions.

Optional harness hardening (advanced): teams who want the model to be physically prevented from ending a session while the verifier is red can register a Stop hook in ~/.claude/settings.json (replace <ARIS_REPO> with the absolute path to your ARIS clone, e.g. /Users/you/Auto-claude-code-research-in-sleep):

{
  "hooks": {
    "Stop": [
      {"command": "bash <ARIS_REPO>/tools/verify_paper_audits.sh paper/ --assurance submission"}
    ]
  }
}

This is not required — the default repo behavior (Phase 6 verifier-as-truth) already blocks Final Report emission on a red verdict. The Stop hook is a belt-and-suspenders layer for teams that want harness-level enforcement.

📖 Full specification: shared-references/assurance-contract.md

🧿 Optional: GPT-5.4 Pro via Oracle

For expert researchers who want the strongest possible reviewer.

Oracle unlocks GPT-5.4 Pro as an ARIS reviewer — the strongest reasoning model available. Pro excels at deep mathematical proof verification, line-by-line code auditing, and complex experimental design critique.

Setup:

# 1. Install Oracle
npm install -g @steipete/oracle

# 2. Add Oracle MCP to Claude Code
claude mcp add oracle -s user -- oracle-mcp

# 3. Restart Claude Code

# 4a. API mode (fast, recommended):
export OPENAI_API_KEY="your-key"

# 4b. Browser mode (free, no API key — log in to ChatGPT in Chrome):
# Just open Chrome → chatgpt.com → log in

Usage — add — reviewer: oracle-pro to any skill:

/research-review "my draft" — reviewer: oracle-pro          # Pro-level paper critique
/proof-checker "paper/" — reviewer: oracle-pro              # deepest mathematical verification
/experiment-audit — reviewer: oracle-pro                    # Pro audits your eval code
/auto-review-loop "scope" — reviewer: oracle-pro            # Pro stress test each round
/idea-creator "direction" — reviewer: oracle-pro            # Pro evaluates your ideas
/rebuttal "paper/ + reviews" — reviewer: oracle-pro         # Pro stress tests your rebuttal

Default is always Codex xhigh. Oracle not installed = zero impact. — reviewer: oracle-pro without Oracle installed = graceful fallback to Codex + warning.

📖 Full specification: shared-references/reviewer-routing.md

🧰 All Skills

🚀 Full Pipeline

🔍 Workflow 1: Idea Discovery & Method Refinement

🔗 Workflow 1.5: Experiment Bridge

🔁 Workflow 2: Auto Research Loop

📝 Workflow 3: Paper Writing

📝 Workflow 4: Rebuttal

🛠️ Standalone / Utility

⚙️ Setup

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 -- codex mcp-server
   

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
   

   If you only need Workflow 1 & 2 (idea discovery + auto review), LaTeX is not required.

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.

# 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

# 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, requires admin or developer mode for junctions):
.\tools\install_aris.ps1 C:\path\to\your-paper-project

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).

# 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

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.)

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

💡 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.

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

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: adds new + updates safe ones

# 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.

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

🌙 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)"
    ]
  }
}

## Remote Server
- gpu: remote
- SSH: `ssh my-gpu-server` (key-based auth, no password)
- GPU: 4x A100
- Conda env: `research` (Python 3.10 + PyTorch)
- Activate: `eval "$(/opt/conda/bin/conda shell.bash hook)" && conda activate research`
- Code directory: `/home/user/experiments/`
- Use `screen` for background jobs: `screen -dmS exp0 bash -c '...'`

## GPU Environment
- gpu: local
- This machine has direct GPU access (no SSH needed)
- GPU: 4x A100 80GB
- Experiment environment: `YOUR_CONDA_ENV` (Python 3.x + PyTorch)
- Activate before any Python command: `The command to activate your experiment environment` (uv, conda, etc.)
- Code directory: `/home/YOUR_USERNAME/YOUR_CODE_DIRECTORY/`

## Vast.ai
- gpu: vast                  # rent on-demand GPU from vast.ai
- auto_destroy: true         # auto-destroy after experiment completes (default)
- max_budget: 5.00           # optional: warn if estimated cost exceeds this

| # | GPU       | VRAM  | $/hr  | Est. Hours | Est. Total | Offer ID |
|---|-----------|-------|-------|------------|------------|----------|
| 1 | RTX 4090  | 24 GB | $0.28 | ~4h        | ~$1.12     | 6995713  |  ← best value
| 2 | A100 SXM  | 80 GB | $0.95 | ~2h        | ~$1.90     | 7023456  |  ← fastest

# Install
uv tool install zotero-mcp-server   # or: pip install zotero-mcp-server

# Add to Claude Code (Local API — requires Zotero desktop running)
claude mcp add zotero -s user -- zotero-mcp -e ZOTERO_LOCAL=true

# Or use Web API (works without Zotero running)
claude mcp add zotero -s user -- zotero-mcp \
  -e ZOTERO_API_KEY=your_key -e ZOTERO_USER_ID=your_id

# Add to Claude Code (point to your vault path)
claude mcp add obsidian-vault -s user -- npx @bitbonsai/mcpvault@latest /path/to/your/vault

git clone https://github.com/kepano/obsidian-skills.git
cp -r obsidian-skills/.claude /path/to/your/vault/

/research-lit "topic" — arxiv download: true              # download top 5 PDFs
/research-lit "topic" — arxiv download: true, max download: 10  # download up to 10

/arxiv "attention mechanism"           # search
/arxiv "2301.07041" — download         # download specific paper

📱 Feishu/Lark Integration (Optional)

Get mobile notifications when experiments finish, reviews score, or checkpoints need your input — without sitting in front of the terminal.

Push Only (group cards)	Interactive (private chat)

Three modes — you choose per-project:

Mode	What happens	You need
Off (default)	Nothing. Pure CLI, no Feishu	Nothing
Push only	Webhook notifications at key events. Mobile push, no reply	Feishu bot webhook URL
Interactive	Full bidirectional. Approve/reject ideas, reply to checkpoints from Feishu	feishu-claude-code running

Push Only Setup (5 min)

Group notifications with rich cards — experiment done, review scored, pipeline complete. Mobile push, no reply needed.

Step 1: Create a Feishu group bot

1. Open your Feishu group (or create a test group)
2. Group Settings → Bots → Add Bot → Custom Bot
3. Name it (e.g., ARIS Notifications), copy the Webhook URL
4. Security: add custom keyword ARIS (all notifications include this word), or leave unrestricted

Step 2: Create config file

cat > ~/.claude/feishu.json << 'EOF'
{
  "mode": "push",
  "webhook_url": "https://open.feishu.cn/open-apis/bot/v2/hook/YOUR_WEBHOOK_ID"
}
EOF

Step 3: Test it

curl -s -X POST "YOUR_WEBHOOK_URL" \
  -H "Content-Type: application/json" \
  -d '{
    "msg_type": "interactive",
    "card": {
      "header": {"title": {"tag": "plain_text", "content": "🧪 ARIS Test"}, "template": "blue"},
      "elements": [{"tag": "markdown", "content": "Push mode working! 🎉"}]
    }
  }'

You should see a blue card in your group. Skills will now automatically send rich cards at key events:

Event	Card color	Content
Review scored ≥ 6	🟢 Green	Score, verdict, top weaknesses
Review scored < 6	🟠 Orange	Score, verdict, action items
Experiment complete	🟢 Green	Results table, delta vs baseline
Checkpoint waiting	🟡 Yellow	Question, options, context
Error	🔴 Red	Error message, suggested fix
Pipeline done	🟣 Purple	Score progression, deliverables

Interactive Setup (15 min)

Everything Push mode does, plus bidirectional private chat with Claude Code via Feishu. Approve/reject ideas, reply to checkpoints, give custom instructions — all from your phone.

How it works: Push cards go to the group (everyone sees status). Interactive conversations happen in private chat with the bot (you reply, Claude Code acts on it).

Step 1: Complete Push setup above first (you'll keep both)

Step 2: Create a Feishu app on open.feishu.cn

1. Click Create Enterprise App → name it (e.g., ARIS Claude Bot) → create
2. Left menu → Add Capabilities → check Bot
3. Left menu → Permissions → search and enable these 5 permissions:

Permission	Scope	Why
im:message	Send & receive messages	Core messaging
im:message:send_as_bot	Send as bot	Bot replies
im:message.group_at_msg:readonly	Receive group @mentions	Group messages
im:message.p2p_msg:readonly	Receive private messages	⚠️ Easy to miss! Without this, the bot connects but never receives your messages
im:resource	Access attachments	Images/files

4. Left menu → Events & Callbacks → select Long Connection mode → add event: im.message.receive_v1 → save

⚠️ Important: The "Long Connection" page may show "未检测到应用连接信息" — this is normal. You need to start the bridge first (Step 3), then come back and save.

5. Left menu → Version Management → Create Version → fill description → Submit for Review

For personal/test Feishu organizations, approval is usually instant.

Step 3: Deploy the bridge

git clone https://github.com/joewongjc/feishu-claude-code.git
cd feishu-claude-code
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

# Configure
cp .env.example .env

Edit .env:

FEISHU_APP_ID=cli_your_app_id          # From app credentials page
FEISHU_APP_SECRET=your_app_secret      # From app credentials page
DEFAULT_MODEL=claude-opus-4-6          # ⚠️ Default is sonnet — change to opus for best results
DEFAULT_CWD=/path/to/your/project      # Working directory for Claude Code
PERMISSION_MODE=bypassPermissions      # Or "default" for safer mode

⚠️ Model matters: The default claude-sonnet-4-6 works but may struggle with complex project context. claude-opus-4-6 correctly identified 18 ARIS skills on first try where sonnet could not.

Start the bridge:

python main.py
# Expected output:
# ✅ 连接飞书 WebSocket 长连接（自动重连）...
# [Lark] connected to wss://msg-frontier.feishu.cn/ws/v2?...

For long-running use, put it in a screen session:

screen -dmS feishu-bridge bash -c 'cd /path/to/feishu-claude-code && source .venv/bin/activate && python main.py'

Step 4: Save event config — Go back to Feishu Open Platform → Events & Callbacks → the long connection should now show "已检测到连接" → Save

If you published the app version before the bridge was running, you may need to create a new version (e.g., 1.0.1) and re-publish after saving event config.

Step 5: Test private chat

1. In Feishu, find the bot in your contacts (search by app name)
2. Send it a message: 你好
3. It should reply via Claude Code

If the bot doesn't reply: Send /new to reset the session, then try again. Common issues:

Symptom	Cause	Fix
Bot connects but never receives messages	Missing im:message.p2p_msg:readonly permission	Add permission → create new version → publish
Bot replies but doesn't know your project	DEFAULT_CWD points to wrong directory	Edit .env → restart bridge
Bot replies but seems less capable	Using claude-sonnet-4-6	Change to claude-opus-4-6 in .env → restart
Old session has stale context	Session cached from before config change	Send /new in chat to start fresh session
"未检测到应用连接信息" when saving events	Bridge not running yet	Start bridge first, then save event config

Step 6: Update ARIS config

cat > ~/.claude/feishu.json << 'EOF'
{
  "mode": "interactive",
  "webhook_url": "https://open.feishu.cn/open-apis/bot/v2/hook/YOUR_WEBHOOK_ID",
  "interactive": {
    "bridge_url": "http://localhost:5000",
    "timeout_seconds": 300
  }
}
EOF

Now skills will:

• Push rich cards to the group (status notifications, everyone sees)
• Private chat you for decisions (checkpoints, approve/reject, custom instructions)

Which skills send notifications?

Skill	Events	Push	Interactive
/auto-review-loop	Review scored (each round), loop complete	Score + verdict	+ wait for continue/stop
/auto-paper-improvement-loop	Review scored, all rounds done	Score progression	Score progression
/run-experiment	Experiments deployed	GPU assignment + ETA	GPU assignment + ETA
/vast-gpu	Instance rented/destroyed	Instance ID + cost	Instance ID + cost
/monitor-experiment	Results collected	Results table	Results table
/idea-discovery	Phase transitions, final report	Summary at each phase	+ approve/reject at checkpoints
/research-pipeline	Stage transitions, pipeline done	Stage summary	+ approve/reject

Not using Feishu? No problem — without ~/.claude/feishu.json, all skills behave exactly as before. Zero overhead, zero side effects.

💡 Alternative IM platforms: The push-only webhook pattern works with any service that accepts incoming webhooks (Slack, Discord, DingTalk, WeChat Work). Just change the webhook_url and card format in feishu-notify/SKILL.md. For bidirectional support, see cc-connect (multi-platform bridge) or clawdbot-feishu.

🎛️ Customization

Skills are plain Markdown files. Fork and customize:

💡 Parameter pass-through: Parameters flow down the call chain automatically. For example, /research-pipeline "topic" — sources: zotero, arxiv download: true passes sources and arxiv download through idea-discovery all the way down to research-lit. This also works for optional sources such as deepxiv and exa: /research-pipeline "topic" — sources: all, deepxiv, exa. You can set any downstream parameter at any level — just add — key: value to your command.

research-pipeline  ──→  idea-discovery      ──→  research-lit
                   ──→  experiment-bridge    ──→  run-experiment
                   ──→  auto-review-loop
                                            ──→  idea-creator
                                            ──→  novelty-check
                                            ──→  research-review

Full Research Pipeline (research-pipeline)

Override inline: /research-pipeline "topic" — auto proceed: false, illustration: mermaid

Auto Review Loop (auto-review-loop)

Idea Discovery (idea-discovery / idea-creator)

Override inline: /idea-discovery "topic" — pilot budget: 4h per idea, sources: zotero, arxiv download: true

Experiment Bridge (experiment-bridge)

Override inline: /experiment-bridge — base repo: https://github.com/org/project

Literature Search (research-lit)

Override inline: /research-lit "topic" — sources: zotero, web, /research-lit "topic" — sources: all, deepxiv, /research-lit "topic" — sources: all, exa, /research-lit "topic" — arxiv download: true, max download: 10

Paper Writing (paper-write)

Override inline: /paper-write — target venue: NeurIPS, illustration: mermaid

General (all skills using Codex MCP)

• Prompt templates — tailor the review persona and evaluation criteria
• allowed-tools — restrict or expand what each skill can do

🔀 Alternative Model Combinations

Don't have Claude / OpenAI API access? You can swap in other models — same cross-model architecture, different providers.

⭐ We strongly recommend Claude + GPT-5.4 (default setup). It's the most tested and reliable combination. Alternative setups work but may require prompt tuning.

Alt C supports tested providers: GLM (Z.ai), Kimi (Moonshot), LongCat (Meituan) as executors; DeepSeek, MiniMax as reviewers. Any OpenAI-compatible API should also work via the generic llm-chat MCP server. Alt D uses Alibaba Coding Plan — one API key for both executor and reviewer, 4 models included (Kimi, Qwen, GLM, MiniMax). Alt E uses ModelScope — free (2000 calls/day), one key, no automation restrictions. Alt G keeps Codex as executor but swaps the reviewer to Claude Code CLI via the local claude-review MCP bridge, with async polling for long paper/review prompts. Alt H uses Google Antigravity as the executor with native SKILL.md support — choose Claude Opus 4.6 (Thinking) or Gemini 3.1 Pro (high) as the execution model. Alt I keeps Codex as executor, adds only a thin skills-codex-gemini-review overlay, and routes the reviewer-aware predefined skills through the local gemini-review MCP bridge with direct Gemini API by default. It is the closest Gemini analogue to the existing Codex+Claude review path, while minimizing skill changes and now also covers poster PNG review via the same bridge. Free-tier availability, rate limits, and data-use terms remain subject to Google's current policy.

* Alt G normally relies on local Codex CLI and Claude Code CLI logins. Direct API keys are optional, not required.

Alt A: GLM + GPT

Only replace the executor (Claude → GLM), keep GPT-5.4 as reviewer via Codex MCP.

npm install -g @anthropic-ai/claude-code
npm install -g @openai/codex
codex setup   # set model to gpt-5.4

Configure ~/.claude/settings.json:

{
    "env": {
        "ANTHROPIC_AUTH_TOKEN": "your_zai_api_key",
        "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
        "API_TIMEOUT_MS": "3000000",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5"
    },
    "mcpServers": {
        "codex": {
            "command": "/opt/homebrew/bin/codex",
            "args": ["mcp-server"]
        }
    }
}

Codex CLI uses your existing OPENAI_API_KEY (from ~/.codex/config.toml or environment) — no extra config needed for the reviewer side.

Alt B: GLM + MiniMax

No Claude or OpenAI API needed. Uses a custom MiniMax MCP server instead of Codex (because MiniMax doesn't support OpenAI's Responses API). Full guide: docs/MINIMAX_MCP_GUIDE.md.

Alt C: Any Executor + Any Reviewer

Mix and match freely using the generic llm-chat MCP server. Supports any OpenAI-compatible API as reviewer. Full guide: docs/LLM_API_MIX_MATCH_GUIDE.md.

Example combinations: GLM + DeepSeek, Kimi + MiniMax, Claude + DeepSeek, LongCat + GLM, etc.

After Setup: Install Skills & Verify

git clone https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep.git
cd Auto-claude-code-research-in-sleep
cp -r skills/* ~/.claude/skills/
claude

⚠️ For non-Claude executors (GLM, Kimi, etc.): Let the model read through the project once to ensure skills are correctly parsed. This is especially important if you've rewritten skills to use a different reviewer MCP (e.g., mcp__llm-chat__chat instead of mcp__codex__codex) — the new executor needs to understand the changed tool call patterns:

Read through this project and verify all skills are working:
/idea-creator, /research-review, /auto-review-loop, /novelty-check,
/idea-discovery, /research-pipeline, /research-lit, /run-experiment,
/analyze-results, /monitor-experiment, /pixel-art

⚠️ Note: Alternative models may behave differently from Claude and GPT-5.4. You may need to tune prompt templates for best results. The core cross-model architecture remains the same.

📋 Roadmap

Done

• Human-in-the-loop checkpoints — idea-discovery and research-pipeline pause at key decision points for user approval. Configurable via AUTO_PROCEED (default: auto-continue; set false to always wait)
• Alternative model combinations — GLM + GPT, GLM + MiniMax fully documented with setup guides. No Claude or OpenAI API required
• Workflow 3: Paper Writing Pipeline — full chain: /paper-plan → /paper-figure → /paper-write → /paper-compile. ICLR/NeurIPS/ICML templates, claims-evidence matrix, publication-quality figures, latexmk auto-fix. Inspired by claude-scholar, Research-Paper-Writing-Skills, baoyu-skills

Planned

• Daemon mode — auto-restart Claude Code session via launchd/systemd for true unattended operation. Currently the orchestration layer requires an active CLI session; state files (REVIEW_STATE.json, AUTO_REVIEW.md) support resuming across sessions, but relaunch is manual (#11)
• Reference-style figure generation — read figures from reference PDFs → identify chart type, color scheme, layout → generate same-style figures with your own data. Sub-goal remaining: Data charts (extract color/font style → matplotlib rcParams). Method diagrams ✅ solved by paper-illustration
• Workflow execution report — after each workflow (1/1.5/2/3) completes, auto-generate a structured summary: what was done, key decisions made, experiments run, results obtained, scores, and time spent. Output as WORKFLOW_REPORT.md for progress tracking, team reporting, and supervisor updates
• Document-based pipeline input — /idea-discovery and /research-pipeline auto-detect RESEARCH_BRIEF.md in project root. Detailed context replaces one-line prompt. Template: templates/RESEARCH_BRIEF_TEMPLATE.md
• Auto hyperparameter tuning skill — rewrite auto-hparam-tuning as an ARIS SKILL.md. 5-step cycle: understand project → plan tuning strategy → run experiments → analyze metrics (TensorBoard/W&B) → learn and iterate. Would plug into Workflow 1.5 (/experiment-bridge) or Workflow 2 (/auto-review-loop) when reviewer says "tune hyperparameters"
• Plugin format — package ARIS as a Claude Code Plugin for one-click install via /plugin install aris. Skills version continues for cross-platform compatibility (Codex CLI, Cursor, Trae, etc.)

💬 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:

📖 Citation

If you use ARIS in your research, please cite:

@misc{yang2026aris,
    author       = {Yang, Ruofeng and Li, Yongcan and Li, Shuai},
    title        = {ARIS: Fully Autonomous Research via Adversarial Multi-Agent Collaboration},
    year         = {2026},
    url          = {https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep},
}

⭐ Star History

🙏 Acknowledgements

ARIS is inspired by:

• 🧪 AI Scientist (Sakana AI) — Automated research pioneer
• 📖 AutoResearch (Andrej Karpathy) — End-to-end research automation
• 🔭 FARS (Analemma) — Fully Automated Research System
• 🎨 PaperBanana (PKU) — Multi-agent academic illustration framework

This project builds on and integrates with many excellent open-source projects:

Core Infrastructure

• Claude Code — Anthropic's CLI for Claude, the execution backbone
• Codex CLI — OpenAI's CLI, used as MCP server for cross-model review

Zotero Integration (setup guide)

• zotero-mcp — Zotero MCP server with semantic search and PDF annotations
• Zotero — Open-source reference manager

Obsidian Integration (setup guide)

• mcpvault — Obsidian vault MCP server (no app required)
• obsidian-skills — Claude Code skills for Obsidian Markdown by Steph Ango (Obsidian CEO)

Paper Writing Inspiration

• claude-scholar — Academic paper writing with Claude
• Research-Paper-Writing-Skills — Paper writing skill templates
• baoyu-skills — Claude Code skills collection

Feishu/Lark Integration (setup guide)

• feishu-claude-code — Bidirectional Feishu ↔ Claude Code bridge
• clawdbot-feishu — Feishu bot for Claude
• cc-connect — Multi-platform messaging bridge
• lark-openapi-mcp — Official Lark MCP server

Community

• awesome-agent-skills — Curated list of Claude Code skills (featured)

Special Thanks — Platform Adaptation

ARIS wouldn't run on so many platforms without these contributors:

• 🤖 @Falling-Flower — adapted all ARIS skills for Codex CLI using spawn_agent
• 🔧 @No-518 — ongoing maintenance of the Codex skill set, keeping parity with latest updates
• 🖱️ @YecanLee — wrote the Cursor adaptation guide and local GPU setup docs
• 🏆 @DefanXue & @Monglitay — first community paper built entirely with ARIS, scored 8/10 at CS conference

Special Thanks — Architecture & Vision

• 💡 @JingxuanKang — beyond code contributions (training-check, result-to-claim, ablation-planner, watchdog, templates, session recovery), deeply shaped ARIS through discussions on architecture design, compact mode, workflow state management, and the vision of what autonomous research workflows should look like. Many of today's core features — from structured project files to context-aware session recovery — grew out of these conversations.

License

MIT