AutoResearchClaw

AutoResearchClaw is an autonomous, collaborative, and self-evolving research system designed to transform a research idea into a complete paper. It supports two primary modes of operation:

1. Fully Autonomous Mode: Operates without human intervention to conduct research and write papers.
2. Co-Pilot Mode: Allows for human-AI collaboration at key decision points (Human-in-the-Loop).

The project is compatible with OpenClaw and provides a framework for generating research papers across various domains such as mathematics, statistics, biology, computer science, NLP, RL, computer vision, and robustness. It is built with Python 3.11+ and is documented in several languages.

ARC-Bench baselines provide self-contained framework integrations for research benchmarking. The directory structure is organized as follows:

• adapters/: Contains FrameworkAdapter implementations (one .py file per baseline). These adapters subclass base.FrameworkAdapter and transform framework outputs into a standard submission/ directory format compatible with scripts/judge.py.
• external/: Contains upstream framework clones (these are gitignored and must be manually installed using the provided setup steps).
• interventions/: Contains scripted Human-In-The-Loop (HITL) JSON files (e.g., T01-T25) used by rc_copilot. These are auto-derived from rc_full failure modes via scripts/hitl_suggestor.py.

ARC-Bench is a 55-topic open-ended autonomous-research benchmark spanning five domains: ML (25), high-energy physics (10), quantum (10), biology (7), and statistics (3).

Each topic is defined by a manifest containing a research question, synthesis, conditions, metrics, datasets, and hypotheses. Frameworks participating in the benchmark must follow a workflow of: code $\rightarrow$ measurements $\rightarrow$ claims $\rightarrow$ writeup. Scoring is performed via rubric-graded multi-criteria audits.

AutoResearchClaw is an autonomous and collaborative research pipeline designed to turn a single research idea into a conference-ready paper. It supports several key paradigms:

• Fully Autonomous: A 23-stage pipeline that requires no human intervention.
• Co-Pilot (Human-in-the-Loop): A collaborative mode that allows humans to intervene at key decision points. It includes 6 intervention modes: full-auto, gate-only, checkpoint, step-by-step, co-pilot, and custom.
• Multi-Domain Expertise: Specialized agents for domains such as High Energy Physics (using ColliderAgent), Biology (using COBRApy), and Statistics.
• Skill Extensibility: Users can install custom skills via researchclaw skills install or by placing a SKILL.md file in .claude/skills/.

Researchclaw is capable of generating high-quality research papers across diverse scientific and technical domains, including:

• Mathematics & Statistics: Random Matrix Theory, Econometrics, and Probability.
• Sciences: Epidemiological Modeling (SIR/SEIR models) and Biology.
• Computing & Engineering: Numerical Linear Algebra and Preconditioning strategies.
• Machine Learning & AI:
  • NLP / PEFT: Parameter-Efficient Fine-Tuning (e.g., LoRA rank allocation).
  • Reinforcement Learning: Count-based exploration and state abstraction.
  • Computer Vision: Efficient Vision Transformers (ViT) and token merging.
  • Robustness / Knowledge Distillation: Contrastive feature alignment and distribution shift robustness.

AutoResearchClaw supports the Agent Client Protocol (ACP). This allows you to use any ACP-compatible coding agent (like Claude Code, Copilot CLI, etc.) as the LLM backend without needing a direct API key in the config. The agent handles authentication via acpx and maintains a persistent session across the 23 pipeline steps.

To use an ACP agent, set the llm.provider to "acp" and specify the agent name under llm.acp.

Supported Agents:

• claude (Anthropic)
• codex (OpenAI)
• gh (GitHub Copilot CLI)
• gemini (Google)
• opencode (SST)
• kimi (Moonshot)

# config.yaml — exemple ACP
llm:
  provider: "acp"
  acp:
    agent: "claude"   # N'importe quel agent CLI compatible ACP
    cwd: "."          # Repertoire de travail pour l'agent
  # Pas besoin de base_url ou api_key — l'agent gere sa propre authentification.

Researchclaw operates through an autonomous pipeline that traverses 23 stages to generate a complete research paper (in NeurIPS PDF format) without human intervention. The process follows this sequence:

1. Idea: Conceptualization of the research topic.
2. Literature: Collection of relevant papers (typically 300–470 papers).
3. Hypothesis: Experiment design and formulation.
4. Code: Implementation of the research logic (typically 2K–15K lines of code).
5. Execute: Running experiments in a sandbox environment with iterative refinement.
6. Write: Drafting the paper, including review and audit stages.
7. Paper: Final generation of the research paper.

The pipeline includes iterative self-healing, multi-agent peer review, and citation verification to ensure quality.