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

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

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

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

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

🚀 Beyond 科研 → 任何 "研究"：ARIS-Anything 把 ARIS 的五步 loop（plan / draft / 对抗审 / 迭代 / 持久化）推广到非学术的结构化研究——投资尽调 / 法律研究 / 市场研究 / 自驱学习 / 调查新闻 / 工程复盘等。

🎬 ARIS goes multimodal → ARIS-Movie-Director — from research & coding into visual generation: hand over a fuzzy story, wake up to a cross-model-audited movie (reference run = 19 scenes). Long-horizon visual stories drift two ways — 🧠 long-range forgetting and 🗣️ self-approved streaming (each frame signed off by the model that drew it). ARIS answers with the same DNA: a research-wiki for memory + multi-agent debate so no frame signs off on itself.

🎞️ A few frames from the reference movie — including the story's own integrity beat (a run that reported +6.2 but really moved +1.4). Image-based today, video next — ▶ watch all 19 scenes →

🎯 准备 2026 AI 秋招？ → 🌐 ARIS-in-AI-Offer · GitHub repo · 中文 README —— 23 篇双语 ML / LLM / 多模态 / 生成式 / Agent 面试 cheat sheet，每篇 = 公式推导 + 从零 PyTorch + 25 高频面试题（L1 / L2 / L3），全部由 ARIS 的 /render-html 自动生成。希望大家秋招轻松一点 🌱

📖 Preview from the Diffusion Foundations cheat sheet — every tutorial in ARIS-in-AI-Offer follows the same three-pillar structure (foundations / interview Q&A / runnable code).

🌐 Same workflow, different deliverable — ARIS-Homepage v1 live demo (CV → fact-checked single-file academic homepage via /homepage-generator).

📝 Three long-form blogs, cross-model collaborative writing via /render-html — Continuous DLM — a representation-perspective survey (2026 H1) · Cosmos 3 — understanding + generation in one Transformer (MoT) · Diffusion × representation × manifold learning.

🛰 社区好物 · Claude Fleet（by @tianyilt）—— 本地只读看板，一眼盯住并行的一堆 Claude Code / Codex 窗口(谁在跑 / 等授权 / 跑完了)，一键跳转 + 全文搜 transcript。多 agent 工作流神器，好用点个 ⭐

🪟 更轻的自家选择 · ARIS-Monitor —— ARIS 自带的 macOS 置顶悬浮小窗(纯 Python · 无浏览器)：只亮"哪个会话在等你授权" 🔴，点一行跳到那个终端。

🖼️ Preview — Claude Fleet dashboard (full web) & ARIS-Monitor widget (minimal, built-in)

Claude Fleet · 全功能网页看板	ARIS-Monitor · 极简悬浮小窗(自带)

cd aris-monitor && ./run.sh
# a borderless panel floats top-right; click a row to jump to that terminal

git clone https://github.com/tianyilt/claude-fleet
cd claude-fleet && bash run.sh
# open http://127.0.0.1:7878 in your browser

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

📰 ARIS-Code v0.4.19 (2026-06) — latest is a honesty / guardrails patch: an MCP protocol-version negotiation guard (stop silently proceeding on an incompatible handshake) plus a few papercut fixes. The headline features remain v0.4.18 — default model Claude Opus 4.8 (with corrected pricing — current Opus/Sonnet had been over-billed up to 5× — and an availability fallback so the bump can't break accounts without 4.8 access) and v0.4.17 — the MCP release: user-configured mcpServers drive real tool dispatch, and cross-model adversarial review needs no OpenAI API key (aris setup wires your ChatGPT subscription in as the reviewer via Codex MCP in one step). Caps a 15-release polish run (v0.4.5 → v0.4.19) — full per-release detail below. Credits: @GetIT-Sunday, @Anduin9527, @GO-player-hhy, @Jxy-yxJ, @screw-44, @StevenUST, @opposj, @ShijunLei-cn, @algojogacor.

Per-release details (v0.4.5 → v0.4.19)

v0.4.19 (2026-06-14) — honesty / guardrails patch (theme from a Codex fresh-eyes audit; no behavior change for healthy setups). 🔴 MCP protocol-version negotiation guard — the stdio handshake requested 2025-03-26 but never read the version the server negotiated back (a parsed-but-dead field), so a server agreeing on a version ARIS can't speak was silently accepted and later tools/list / tools/call ran on an incompatible protocol with opaque failures. ARIS now validates the negotiated version against a supported set (2025-11-25 / 2025-06-18 / 2025-03-26 / 2024-11-05 — stdio framing is identical across these) and, on an unsupported one, terminates the child + clears the slot + surfaces a clear per-server error (aris doctor shows it) — the "terminate when versions can't be agreed" behavior the MCP lifecycle spec requires. The request stays 2025-03-26 (proven against codex mcp-server), so healthy servers are unaffected — verified end-to-end: the real Codex MCP server still spawns + initializes + advertises its tools under the guard. 🧹 Papercuts: the OpenAI-family subagent fail-loud message dropped its stale "lands in v0.4.18" marker (now version-agnostic + actionable, still credential-free); OpenAI upstream error bodies are now truncated (500 chars) + credential-redacted (sk-… keys and Bearer … tokens, via a substring scanner that catches the compact-JSON shape {"api_key":"sk-…"} a misconfigured proxy can reflect back) instead of splatted verbatim; the system-prompt hook-events summary now counts only the hooks the runtime actually executes (a command hook with a command string), matching the parser. Tests (CI mode): api 32 / runtime 204 / tools 67 / aris-cli 167 / commands 5, all green; live smoke confirms the real Codex MCP server still initializes under the guard. Reviewed by Codex MCP (gpt-5.5 xhigh): design GO → impl NO-GO (compact-secret miss + command-string strictness) → GO after fixes.

v0.4.18 (2026-06-14) — default model → Claude Opus 4.8, with corrected pricing and a safety net. The bump moves DEFAULT_MODEL, the opus alias, the model picker, aris setup, and the subagent default to claude-opus-4-8 — with an availability fallback: if the account lacks 4.8 (the API returns 404 not_found_error), ARIS auto-falls-back to claude-opus-4-7 for the session, rebuilds the system-prompt model identity so it stays coherent (the model is never told it's 4.8 while served 4.7), warns once, and retries — for the main session (text + JSON) and subagents. It fires only on that precise 404 (never 400/rate-limit/auth), latches against loops, and the text path rebuilds from a pre-turn snapshot so a retry never double-appends the user message; accounts with 4.8 are byte-identical to a plain bump. 💰 Pricing corrected (verified against Anthropic's published schedule; had been a 3–5× over-estimate): current Opus 4.5–4.8 = $5/$25 (deprecated Opus 4/4.1 keep $15/$75, split by word-boundary so a future opus-4-10 isn't mis-tiered); Sonnet 4.x = $3/$15 (decoupled from the generic unknown-model fallback, which stays $15/$75); Haiku was already correct. 🧹 Backlog: aris setup option 10 pins the Codex MCP reviewer to model_reasoning_effort="xhigh" (deterministic for new setups, independent of ~/.codex/config.toml; idempotent merge never clobbers an existing entry); a startup + aris doctor misconfig hint (#259) for a silently-ignored/misplaced config (malformed JSON, or a stray ~/.aris/config.yaml — stderr-only so --print/JSON stdout stays clean); the system-prompt hook summary now marks parsed-but-never-fired events "PARSED ONLY … will NOT run" instead of implying dead hooks run (full event expansion — actually firing SessionStart/SessionEnd/… — deferred to a separate issue). Tests (CI mode): api 32 / runtime 202 / tools 67 / aris-cli 166 / commands 5, all green; a live one-shot smoke returns model=claude-opus-4-8 end-to-end. Reviewed by Codex MCP (gpt-5.5 xhigh) across the design + both implementation batches (design REWORK→GO, impl NO-GO→GO, batch-2 GO).

v0.4.17 (2026-06-13) — the MCP release. Before v0.4.17, mcpServers in settings.json parsed, showed in aris doctor, and did nothing; now ARIS spawns each configured stdio server, runs the MCP handshake, discovers tools, and advertises them as mcp__<server>__<tool> on both provider paths (Anthropic + OpenAI-family), with end-to-end dispatch, soft per-server degradation, and an approval gate for untrusted MCP tools (external processes the sandbox can't cover; --allowedTools now accepts mcp__ names). 🆕 zero-API-key cross-model reviewer: aris setup → option 10 (Codex MCP, ChatGPT subscription, no API key) writes an idempotent mcpServers.codex entry into the settings file the runtime actually reads (atomic write + backup, explicit consent before trust: true), with an optional API reviewer as fallback (ARIS_REVIEWER_PROVIDER=codex-mcp + ARIS_REVIEWER_FALLBACK_PROVIDER); /setup in-REPL rebuilds the system prompt + runtime so reviewer changes take effect without quitting. 🔴 Protocol fix the fakes couldn't catch: real-machine e2e against codex mcp-server exposed that our stdio transport spoke LSP-style Content-Length: framing while the MCP spec (and codex) use newline-delimited JSON-RPC — every fake-server test passed because the fakes spoke the same wrong dialect; writes are now NDJSON, reads auto-detect both, and the spec-mandated notifications/initialized is sent after initialize (a select-based round-trip also closes the #286 large-request deadlock). Hooks: object-style Claude Code hooks preserve matcher / timeout / async (anchored-regex matcher filtering; per-hook timeout, default 30 s kill = warning not deny). Long tail: ARIS_DISABLE_KEYCHAIN gate, Anthropic stop_reason clean-EOF symmetry (CL2), OpenAI tool-call index-missing merge-by-id (OE6), slash commands enter history. Real-machine push-gate hardening (the zero-key reviewer's first run): codex codex/event notification spam silenced by default (gated behind ARIS_MCP_STDERR=inherit), the system prompt now tells the model not to pass a model parameter to Codex (account default = gpt-5.5 + xhigh; arbitrary names are rejected by a ChatGPT account), and a Codex-MCP-primary-with-no-fallback LlmReview call returns a clear "use mcp__codex__codex" message instead of a misleading OPENAI_API_KEY/gpt-5.5 error. Built with the v0.4.16 zero-regression methodology (24 new characterization tests; every deliberate flip annotated in-place). Tests (CI mode): runtime 199 / aris-cli 165 / tools 67 / api 30 / commands 5, all green. Reviewed phase-by-phase by Codex MCP (gpt-5.5 xhigh) across 17 rounds (7 NO-GOs all resolved). Subagent MCP routing (P8) + MCP protocolVersion bump + hook async execution deferred to v0.4.18.

v0.4.16 (2026-05-30) — REPL UX + provider hardening, shipped under a zero-regression discipline: 64 characterization ("golden") tests locked the current provider-routing / pricing / reviewer / subagent / REPL behavior first, then stayed green through every change. Closes #274: command history now persists to ~/.config/aris/history (0600) and reloads on startup, with an ARIS_NO_HISTORY kill-switch and a disk-only secret-skip (credential-looking lines stay in in-session history but never touch disk); bash-style Ctrl+R reverse incremental search (CJK display-width-aware single-line render; no existing key binding changed; no new dependency). Security: an OpenAI-family main session (Kimi / GLM / MiniMax / …) spawning a subagent previously silently billed the user's Anthropic OAuth/Keychain credential — it now fails loud with a clear, credential-free error; full OpenAI-family subagent routing is a cross-crate change deferred to v0.4.17. Groundwork (no behavior change): the 3 byte-identical word-boundary matchers consolidate into one canonical runtime::word_match; new pure ProviderFamily classifier (unwired). Tests (CI mode): runtime 164 / aris-cli 128 / tools 49 / commands 5, all green. Codex MCP (gpt-5.5 xhigh) reviewed each phase + a final integration pass.

v0.4.15 (2026-05-29) — OpenAI-compatible streaming robustness hotfix. Closes #249: MiniMax (and other OpenAI-compatible providers / proxies) were effectively unusable because the clean-EOF completion check treated the data: [DONE] SSE sentinel as the only authoritative signal. A non-empty choices[].finish_reason is the Chat Completions spec's terminal-chunk marker; [DONE] is a transport convention some compatible providers never emit (MiniMax sends finish_reason: "stop" then closes without [DONE]). The clean-EOF decision is now a pure, unit-tested stream_eof_action(...) that completes on EITHER [DONE] OR a non-empty finish_reason; reads are NOT stopped early at finish_reason (a trailing include_usage usage-only chunk is still consumed), genuine truncation still hard-errors, and a pre-output proxy abort still restarts. Coupled fixes: OE7 reads finish_reason before the delta guard (delta-less terminal choice); OE2 flushes pending tool calls on any non-empty finish_reason; OE4 surfaces a mid-stream error envelope as a hard error instead of silently dropping it; OE3 tolerates data:{...} without the space after the colon. +5 unit tests (77→82) extract the previously-untested SSE completion logic into pure helpers. Anthropic SSE path untouched. Codex MCP (gpt-5.5 xhigh) 3 rounds (GO-WITH-NITS → GO-WITH-NITS → GO).

v0.4.14 (2026-05-25) — Security-hygiene release closing the top items from the v0.4.13 codex audit (gpt-5.5 xhigh, 6/10 NEEDS-REWORK verdict). 🔴 S9 (P0) system-prompt config redaction — before v0.4.14, render_config_section() dumped the merged settings.json verbatim into the system prompt sent to the LLM provider, leaking env, mcpServers.<name>.headers.Authorization Bearer tokens, hook command env, signed-URL query params, and apiKey fields. New renderer whitelists top-level fields (model/permissionMode/theme/outputStyle/permissions/sandbox with recursive redaction inside), redacts sensitive keys (apikey/token/secret/password/authorization/headers/env/_KEY/_SECRET/_TOKEN), replaces MCP command with <configured> placeholder, reduces MCP url to strict <scheme://host[:port]> origin (scheme allow-list http/https/ws/wss, ASCII host, digit-only port, IPv6 brackets), and drops hook command strings entirely. Regression test exercises 9 distinct leak surfaces; URL parser has its own targeted test for 7 smuggling attempts including port-position secret injection (codex round-3 catch). 🟡 P9 (P1): DeepSeek aris --help now points at aris setup option 7 instead of an env-var path the resolver never honored. 🟡 M1/M2 (P1) doc: aris doctor + README/README_CN gain experimental warning whenever mcpServers.len() > 0 (full MCP tool dispatch lands v0.4.16). 🟢 C11 (P2) stream idle timeout — both Anthropic MessageStream and the OpenAI SSE loop wrap response.chunk().await in tokio::time::timeout (env ARIS_STREAM_IDLE_TIMEOUT_SECS, default 120, clamp [10, 1800], 0/negative disables); closes the "aris hangs forever with no output" symptom when an upstream HTTPS proxy holds a connection without keepalives. Bundle: 77 skills (+1 /wiki-enrich via late same-day sync to main 7e3ab67 which also picks up upstream check_ready.sh awk + grep-c null-match fix), 54 helpers. Codex MCP 6 rounds (NO-GO + 4 → GO-WITH-NITS + 3 → NO-GO + port smuggling → GO → release metadata GO → sync GO).

v0.4.13 (2026-05-25) — Residue-cleanup release closing every codex audit P1 carried since v0.4.10–v0.4.12, plus the long-tail regression tests. 🟡 v0.4.10 P1.D per-server MCP timeout — mcpServers.<name>.requestTimeoutSecs override > MCP_REQUEST_TIMEOUT_SECS env > 300s default (clamped 1..=1800), so one Codex MCP agent can run 5 min while filesystem MCP errors in 5 s. 🟡 v0.4.10 known limitation closed — McpStdioProcess::request() skips JSON-RPC notifications (id absent/null) and keeps reading until the correlated response. 🟢 meta_opt hook deploy via aris init — tools/meta_opt/{log_event,check_ready}.sh bundle into the binary; aris init writes ARIS-namespaced aris-meta-opt-log-event.sh / aris-meta-opt-check-ready.sh to ~/.claude/hooks/ (codex round-1 #1: never clobbers user hooks); settings.json merge idempotent, backups hard-fail, final rewrite atomic via tempfile + rename. 🧪 9 v0.4.12 targeted regression tests for sandbox.strictMode (3) + parse strictMode + provider_match pricing + has_word o-series + stream_options 400 + meaningful-content classification + premature-EOF retry truth table (codex round-1 #3 — should_retry_on_premature_eof() extracted to pure fn, 7-row test). Bundle: 76 skills, 54 helpers (+2 meta_opt scripts vs v0.4.12). Codex 3 rounds (NO-GO + 3 → NO-GO + metadata → GO).

v0.4.12 (2026-05-22) — Bug-fix + small-feature release. #238 sandbox.strictMode opt-in config key; when set, SandboxConfig::resolve_request() ignores all five LLM-supplied overrides (dangerouslyDisableSandbox, namespaceRestrictions, isolateNetwork, filesystemMode, allowedMounts) — closes the gap where a tool call could silently bypass user sandbox policy. aris doctor adds a "Sandbox:" row; bash tool schema documents the strictMode semantics. #232 auto-review-loop-llm updated from legacy deepseek-chat / deepseek-reasoner (deprecate 2026-07-24; reasoner rejects tool_choice) to deepseek-v4-flash / deepseek-v4-pro. v0.4.10 audit P1 follow-ups: P1.A Anthropic stream retry gates on has_emitted_meaningful_content (a stream that only sent MessageStart before EOF is retry-eligible); P1.B supports_reasoning_effort + reviewer mirror use word-boundary match so openai/o3-mini / proxy:o4 route correctly; P1.C stream_options.include_usage:true proxy fallback retries once without on real 400 unknown-field errors; P2 pricing match precision via provider_match() so qwen3.6-plus / kimi-k2.5 route correctly while my-kimi-clone does not. Skills sync (76 skills, 52 helpers): /interview-cheatsheet + /render-html newly bundled; build.rs ALLOWED_EXTS gains html for render-html templates; EXCLUDED_SKILL_PREFIXES → starts_with("skills-codex"). CI fetch-depth: 0 + origin/main fetch so drift-test ancestor check runs. Cross-reviewed by Codex MCP (gpt-5.5 xhigh) over 4 rounds.

v0.4.11 (2026-05-18) — Skills bundle refresh + sync infrastructure. The embedded skills set in the v0.4.10 binary had fallen behind main (~6 of 56 main skills/ commits had been cherry-picked); v0.4.11 syncs the full set and ships sync infrastructure so the gap can't silently reopen. Bundle: 65→74 user-facing skills, 34→49 helper resources. 10 new skills bundled: /citation-audit (fourth-layer bibliography audit), /experiment-queue (SSH multi-seed job queue with OOM retry), /kill-argument (two-thread adversarial review for theory papers), /resubmit-pipeline (W5: text-only port to a new venue), /paper-talk (end-to-end conference talk pipeline), /slides-polish (per-page Codex layout review), /overleaf-sync (two-way Overleaf Git-bridge), /gemini-search + /openalex (broader literature sources), /qzcli (Qizhi GPU jobs). 46 existing SKILL.md refreshed — most critically the canonical resolver chain rollout (closes real user incident where /research-wiki was empty for a week from hardcoded tools/research_wiki.py), submission assurance gate + external verifier (/paper-writing Phase 6 now functions). tools/ goes 9→18: 9 baseline helpers refreshed (research_wiki.py 315→767 lines with canonical ingest_paper API), 9 new helpers (extract_paper_style.py, figure_renderer.py, paper_illustration_image2.py, overleaf_{setup,audit}.sh, verify_wiki_coverage.sh, watchdog.py, experiment_queue/{build_manifest,queue_manager}.py). New tools/sync_main_skills.sh automates main → bundle rsync with symlink pre-flight + codex-mirror prune + SKILLS_SOURCE_COMMIT pinning. 3 new CI drift tests in crates/runtime/src/cache.rs cover all 4 resolver layer patterns. Gemini MCP calls in /research-lit and /gemini-search now pass model: 'auto-gemini-3' (avoids silent downgrade to 2.5-pro on OAuth-personal capacity exhaustion). CLI runtime unchanged — codex-audit P1 follow-ups remain on v0.4.12 backlog. Cross-reviewed by Codex MCP (gpt-5.5 xhigh) across 5 rounds (REQUEST CHANGES → APPROVE WITH NITS → NO-GO → GO → final GO).

v0.4.10 (2026-05-17) — Stream + MCP reliability + multi-provider pricing. C6 whole-stream restart in Anthropic MessageStream + OpenAI SSE loop on chunk decode failure / premature EOF (ARIS_STREAM_RETRY, default 2, clamp 0..=5, fires only when nothing emitted yet — closes #228-style "error decoding response body" loop). M3 MCP stdio gains 300s default tokio::time::timeout over send+read (override MCP_REQUEST_TIMEOUT_SECS, clamp 1..=1800); response.id ↔ request.id correlation; ensure_server_ready() try_wait() dead-process respawn; kill().await on all failure paths so the next call starts clean (closes #151 / #172 "Calling codex..." stalls). C8/P4 OpenAI streaming requests now send stream_options.include_usage:true + parse cached_tokens; Anthropic streaming merges MessageStart.usage (input/cache) with MessageDelta.usage (output). C9 multi-provider pricing registry (15+ models, OpenAI cache_read = input × 0.1 corrects 5× generic overstatement, DeepSeek cache_hit/cache_miss tiers, has_word() boundary matcher for provider/<model> slugs). 9 dead-code warnings cleared; aris setup help text synced with actual behaviour.

v0.4.9 (2026-05-17) — Closes Codex v0.4.7 audit residuals (L1 TLS double-stack, L3 reasoning_cache compaction misalign, L4 reasoning replay unbounded). 2 new skills bundled (/figure-spec + /paper-illustration-image2 with scripts/ subdirs, new Layer 0b = $ARIS_CACHE_DIR/skills/<name>/scripts/); research_wiki.py promoted to shared tools/ (9+ callers); 5 more SKILL.md migrated to fallback chain.

v0.4.8 (2026-05-17) — Skill helper subsystem rewrite. Bundled helpers extract to ~/.config/aris/cache/<version>/ at startup; every Skill invocation surfaces helperReport JSON + 4-layer resolver preamble; /skills export copies helpers; new integration-contract.md with 6 failure policies; 8 shared helpers (arxiv/deepxiv/exa/S2/openalex/save_trace/verify_papers/verify_paper_audits) bundled; /research-lit + /deepxiv migrated. Plus 4 bug fixes: gpt-5.5+tools 400 on OpenAI; Custom reviewer reset; missing signature field (#228); --version Build date hardcoded.

v0.4.7 (2026-05-16) — DashScope Coding Plan 405 fixed (#159) via native-tls switch (#225); reasoning_content replay for all reasoning models (OpenAI o1/o3/o4 / DeepSeek-R1 etc.), not just Kimi (#226); 600+ lines dead code cleanup + rustyline dep removed + "Claw Code" → "ARIS-Code" rebrand.

v0.4.6 (2026-05-14) — 🚨 Two long-standing silent bugs fixed: PermissionMode::Prompt silently allowed every tool (derived-Ord bug); system prompt hardcoded current_date = "2026-03-31" made models reject post-cutoff data as future/prompt-injection. Plus Custom OpenAI-compatible provider (/setup option 11) with dynamic /models discovery (@Anduin9527 #221 + #222).

v0.4.5 (2026-05-13) — First-class reasoning-model support: thinking content blocks end-to-end (fixes #161) + reasoning_effort='xhigh' for GPT-5.5 / o1 / o3 / o4 / DeepSeek-thinking. DeepSeek V4 Pro + Xiaomi MiMo + Qwen 3.6 + Doubao in /setup (options 7-10). Object-style hooks parser. Default model bumped to Claude Opus 4.7 + GPT-5.5. REPL input hardening (multi-line wrap / Cmd+V paste / CJK boundary). GitHub Actions CI. Credits: @GO-player-hhy (#186), @Jxy-yxJ (#171), @GetIT-Sunday (#216 partial).

Older versions

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

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

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-M3 + GLM-5 or GLM-5 + MiniMax-M3. 🤖 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. 🐙 Copilot CLI — GitHub's terminal agent (native SKILL.md + MCP). 🆓 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.5 xhigh) is slower but more deliberate and rigorous in critique. These complementary styles — speed × rigor — produce better outcomes than either model talking to itself.

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

Contents

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

1. 🎯 More Than Just a Prompt

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

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

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

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

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

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

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

🔥 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-html "paper/" # → measurement-gated HTML/CSS poster → print-ready PDF

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

2. 📢 What's New

• 2026-06-07 — 🖼️ /paper-poster-html — new DEFAULT poster pipeline (skill #79); LaTeX /paper-poster retired to a redirect stub. Builds the poster as a single HTML/CSS file on the venue's exact print canvas and iterates by measuring, not eyeballing: hard gates (column-balance spread < 5 px, two-hue design-token discipline, real-paper-figure provenance manifest, figure-area bands) must PASS before any reviewer sees the poster; a closed fix vocabulary (token / component / rebalance / asset / canvas) structurally kills the cosmetic patch-loop; a fresh cross-model review acquits content fidelity (claim→evidence audit + final print-readiness pass). Ships 3 templates + a catalogued component library (incl. density components: equation anatomy, flow-strip, duo figures, derived-Δ tables, claim pills) and 6 venue token packs. Core gate machinery adapted from posterly (MIT, by @Chenruishuo) — ARIS adds the style/asset gates, the density system, and the cross-model loop. ⚠️ /paper-poster now redirects to /paper-poster-html; the legacy LaTeX pipeline remains only in git history.
• 2026-05-31 — 🤝 Community spotlight — two tools worth a look. Claude Fleet (@tianyilt) — a local read-only dashboard to triage / Focus / full-text-search across many concurrent Claude Code + Codex windows. posterly (@Chenruishuo) — a Claude Code skill that builds academic conference posters as a single HTML/CSS file → print-ready PDF via headless Chromium (no LaTeX). Both indexed under Awesome Community. 🌟 if they help you.

3. 🚀 Quick Start

# 1. Install skills — project-local symlinks (recommended)
git clone https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep.git
bash Auto-claude-code-research-in-sleep/tools/install_aris.sh ~/your-project   # symlinks ARIS skills into <project>/.claude/skills/
# (prefer a global install instead? cp -r Auto-claude-code-research-in-sleep/skills/* ~/.claude/skills/)

# 1b. Update later (when upstream changes)
cd Auto-claude-code-research-in-sleep && git pull
bash tools/smart_update.sh --apply   # updates safe skills, flags your personal customizations

# 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.5 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
> /resubmit-pipeline "paper/" — venue: NeurIPS  # Workflow 5: port a polished paper to a new venue (text-only, no new experiments)
> /paper-talk "paper/" — venue: ICLR            # Workflow 6: paper → Beamer + PPTX talk + speaker notes + assurance audits
> /research-pipeline "your research direction"  # Full pipeline: Workflow 1 → 1.5 → 2 → 3 end-to-end
> /research-wiki init                           # 📚 Enable persistent research memory (one-time)
> /meta-optimize                                # Meta: analyze usage logs → propose skill improvements

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

# 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

pip install deepxiv-sdk

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

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

/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.5 Pro reviewer — ultimate mode
/research-pipeline "your topic" — effort: lite                                # quick exploration, save tokens
/research-pipeline "your topic" — effort: max, review_rounds: 3               # max effort but cap review at 3 rounds
/research-pipeline "your topic" — AUTO_PROCEED: false, human checkpoint: true  # combine options
/proof-checker "paper/" — reviewer: oracle-pro                                # Pro-level proof verification

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

4. ✨ Features

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

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

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

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

5. 📈 Score Progression (Real Run)

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

6. 🏆 Community Showcase — Papers Built with ARIS

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

Reviewer screenshots

7. 🧩 Awesome Community Skills & Extensions

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

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

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

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

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

8. 🔄 Workflows

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

• Exploring a new area (e.g., writing a survey)? Start with Workflow 1 → /idea-discovery
• Have a plan, need to implement and run? Workflow 1.5 → /experiment-bridge
• Already have results, need iterative improvement? Workflow 2 → /auto-review-loop
• Ready to write the paper? Workflow 3 → /paper-writing (or step by step: /paper-plan → /paper-figure → /paper-write → /paper-compile → /auto-paper-improvement-loop)
• Got reviews back? Need to rebuttal? Workflow 4 → /rebuttal — parse reviews, draft safe rebuttal, follow-up rounds
• Full pipeline? Workflow 1 → 1.5 → 2 → 3 → submit → 4 → /research-pipeline + /rebuttal — from idea through submission and rebuttal
• 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.5 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.5 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.5 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.5  │────▶│ 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.5 reviews → identifies weaknesses → suggests experiments → Claude Code writes scripts, deploys to GPU, monitors results, rewrites the paper — all while you sleep. Just add your GPU server config to CLAUDE.md.

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

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

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

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

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

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

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

Workflow 3: Paper Writing Pipeline 📝

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

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

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

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

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

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

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

Auto Paper Improvement Loop ✨

After Workflow 3 generates the paper, /auto-paper-improvement-loop runs 2 rounds of GPT-5.5 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).

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.5 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.5  │◀────│ Draft    │               │
│   │ 2 versions│    │ stress   │     │ rebuttal │               │
│   │          │     │ test     │     │          │               │
│   └──────────┘     └──────────┘     └──────────┘               │
│         │                                                        │
│         ▼                                                        │
│   PASTE_READY.txt (strict) + RICH.md (extended)                  │
│         │                                                        │
│         ▼                                                        │
│   Follow-up rounds (delta replies, per-reviewer threads)         │
└─────────────────────────────────────────────────────────────────┘

Skills involved: rebuttal

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

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

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

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

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

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

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

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

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

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

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 🎉

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

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

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

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

Skills involved: meta-optimize

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

⚡ Effort Levels

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

Assurance Gate (effort: max | beast)

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

🧿 Optional: GPT-5.5 Pro via Oracle

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

9. ⚙️ Setup

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

10.1 Prerequisites

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

   Copy

   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:
   hljs language-bash

   Copy

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

10.2 Install Skills

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

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

# 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, no WSL required; creates flat per-skill junctions):
.\tools\install_aris.ps1 C:\path\to\your-paper-project -Platform claude
.\tools\install_aris.ps1 C:\path\to\your-codex-project -Platform codex

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

# 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

10.3 Update Skills

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

# 🧠 Smart update (recommended) — analyzes what's safe to update
bash tools/smart_update.sh          # dry-run: shows what would change
bash tools/smart_update.sh --apply  # apply: 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.

10.4 Usage

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

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

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

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

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

10.5 🌙 Auto-Allow for Overnight Runs (Optional)

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

🖥️ GPU for Auto-Experiments (Optional)

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

🔌 Integrations (Optional)

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

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

10. 🎛️ Customization

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

11. 🔀 Alternative Model Combinations

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

12. 💬 Community

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

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

13. 📖 Citation

If you use ARIS in your research, please cite:

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

14. ⭐ Star History

15. 🙏 Acknowledgements

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

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

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

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

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

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

16. License

MIT