domains / research / autonomous-review-loop / auto-review-loop-minimax

auto-review-loop-minimax

Skill card

combined

The two copies are the same MiniMax-based autonomous review loop, but they disagree on the stop condition, file locations, and allowed tools. The wanshuiyin copy is more specific (review-stage/ paths, legacy fallbacks, explicit AND stop condition, warning against external schedulers), while the brycewang copy uses project-root paths and an OR-based stop condition with different verdict vocabulary. Crowning one would hide a real alternative, so the combined instruction preserves both variants and flags the conflicts.

Repositories

Other copies

Combined skill

---
name: auto-review-loop-minimax
description: Autonomous multi-round research review loop using MiniMax API. Use when you want to use MiniMax instead of Codex MCP for external review. Trigger with "auto review loop minimax" or "minimax review".
argument-hint: "[topic-or-scope]"
allowed-tools: Bash(*), Read, Grep, Glob, Write, Edit, Agent, Skill
---

# Auto Review Loop (MiniMax Version): Autonomous Research Improvement

> 🔒 **Do not wrap this skill in `/loop`, `/schedule`, or `CronCreate`.** It already loops internally (review → fix → re-review), feeding each round's prior-round summary into the next review prompt. An external timer re-enters from the top each tick, dropping accumulated context and firing the verdict on wall-clock time instead of on artifact change — zero new signal, full token cost. Schedule the *external wait that precedes it*, not the verdict.

Autonomously iterate: review → implement fixes → re-review, until the external reviewer gives a positive assessment or MAX_ROUNDS is reached.

## Context: $ARGUMENTS

## Constants

- MAX_ROUNDS = 4
- POSITIVE_THRESHOLD: score >= 6/10 **AND** verdict ∈ {"ready", "almost"} — **both** must hold. Verdict vocabulary is {"ready", "almost", "not ready"}. (Earlier wording used `or` and a stale verdict set; the `AND` form is authoritative.)
- REVIEW_DOC: `review-stage/AUTO_REVIEW.md` (cumulative log) *(fall back to `./AUTO_REVIEW.md` for legacy projects)*
- REVIEWER_MODEL = `MiniMax-M3` — Model used via MiniMax API

## API Configuration

This skill uses MiniMax API for external review. Two methods are supported:

### Method 1: MCP Tool (Primary)

If `mcp__minimax-chat__minimax_chat` is available, use it:

```
mcp__minimax-chat__minimax_chat:
  prompt: |
    [Review prompt content]
  model: "MiniMax-M3"
  system: "You are a senior machine learning researcher..."
```

### Method 2: curl (Fallback)

If MCP is not available, use curl directly:

```bash
curl -s "https://api.minimax.io/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {"role": "system", "content": "You are a senior ML researcher..."},
      {"role": "user", "content": "[Review prompt]"}
    ],
    "max_tokens": 4096
  }'
```

**API Key**: Read from `~/.claude/settings.json` under `env.MINIMAX_API_KEY`, or from environment variable.

**Why MiniMax instead of Codex MCP?** Codex CLI uses OpenAI's Responses API (`/v1/responses`) which is not supported by third-party providers. See: https://github.com/openai/codex/discussions/7782

## State Persistence (Compact Recovery)

Long-running loops may hit the context window limit, triggering automatic compaction. To survive this, persist state to `review-stage/REVIEW_STATE.json` after each round:

```json
{
  "round": 2,
  "status": "in_progress",
  "last_score": 5.0,
  "last_verdict": "not ready",
  "pending_experiments": ["screen_name_1"],
  "timestamp": "2026-03-13T21:00:00"
}
```

**Write this file at the end of every Phase E** (after documenting the round). Overwrite each time — only the latest state matters.

**On completion** (positive assessment or max rounds), set `"status": "completed"` so future invocations don't accidentally resume a finished loop.

## Workflow

### Initialization

1. **Check for `review-stage/REVIEW_STATE.json`** *(fall back to `./REVIEW_STATE.json` if not found — legacy path)*:
   - If neither path exists: **fresh start** (normal case)
   - If it exists AND `status` is `"completed"`: **fresh start** (previous loop finished normally)
   - If it exists AND `status` is `"in_progress"` AND `timestamp` is older than 24 hours: **fresh start** (stale state from a killed/abandoned run — delete the file and start over)
   - If it exists AND `status` is `"in_progress"` AND `timestamp` is within 24 hours: **resume**
     - Read the state file to recover `round`, `last_score`, `pending_experiments`
     - Read `review-stage/AUTO_REVIEW.md` to restore full context of prior rounds *(fall back to `./AUTO_REVIEW.md`)*
     - If `pending_experiments` is non-empty, check if they have completed (e.g., check screen sessions)
     - Resume from the next round (round = saved round + 1)
     - Log: "Recovered from context compaction. Resuming at Round N."
2. Read project narrative documents, memory files, and any prior review documents
3. Read recent experiment results (check output directories, logs)
4. Identify current weaknesses and open TODOs from prior reviews
5. Initialize round counter = 1 (unless recovered from state file)
6. Create/update `review-stage/AUTO_REVIEW.md` with header and timestamp

### Loop (repeat up to MAX_ROUNDS)

#### Phase A: Review

Send comprehensive context to the external reviewer.

**Check MCP availability first**, then use appropriate method:

**If MCP available (Primary):**
```
Use mcp__minimax-chat__minimax_chat tool with:
- system: "You are a senior machine learning researcher serving as a reviewer for top-tier conferences like NeurIPS, ICML, and ICLR. Provide rigorous, constructive feedback."
- prompt: [Full review prompt with context]
- model: "MiniMax-M3"
```

**If MCP NOT available (Fallback):**
```bash
curl -s "https://api.minimax.io/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $MINIMAX_API_KEY" \
  -d '{
    "model": "MiniMax-M3",
    "messages": [
      {
        "role": "system",
        "content": "You are a senior machine learning researcher serving as a reviewer for top-tier conferences like NeurIPS, ICML, and ICLR. Provide rigorous, constructive feedback."
      },
      {
        "role": "user",
        "content": "[Round N/MAX_ROUNDS of autonomous review loop]\n\n[Full research context: claims, methods, results, known weaknesses]\n[Changes since last round, if any]\n[For round 2+: Summary of previous review feedback and what was addressed]\n\nPlease act as a senior ML reviewer (NeurIPS/ICML level).\n\n1. Score this work 1-10 for a top venue\n2. List remaining critical weaknesses (ranked by severity)\n3. For each weakness, specify the MINIMUM fix (experiment, analysis, or reframing)\n4. State clearly: is this READY for submission? Yes/No/Almost\n\nBe brutally honest. If the work is ready, say so clearly."
      }
    ],
    "max_tokens": 4096
  }'
```

**Note**: Each round is a standalone API call. For round 2+, include the summary of previous reviews and changes in the prompt itself.

#### Phase B: Parse Assessment

**CRITICAL: Save the FULL raw response** from the external reviewer verbatim (store in a variable for Phase E). Do NOT discard or summarize — the raw text is the primary record.

Then extract structured fields:
- **Score** (numeric 1-10)
- **Verdict** ("ready" / "almost" / "not ready")
- **Critical weaknesses** (ranked list)
- **Minimum fixes** (per weakness)

#### Phase C: Implement Fixes

For each critical weakness, implement the minimum fix specified by the reviewer. Prioritize by severity. If a fix requires a new experiment, launch it and add to `pending_experiments`.

#### Phase D: Re-review

If fixes were implemented, proceed to the next round (Phase A). If no fixes were possible, proceed to Phase E.

#### Phase E: Document Round

1. Append the full raw reviewer response to `review-stage/AUTO_REVIEW.md`
2. Update `review-stage/REVIEW_STATE.json` with current round, status, last_score, last_verdict, pending_experiments, and timestamp
3. If the stop condition is met (score >= 6/10 AND verdict in {"ready", "almost"}) or MAX_ROUNDS is reached, set `"status": "completed"` in the state file and exit the loop

## Conflicts

- **wanshuiyin/Auto-claude-code-research-in-sleep** uses POSITIVE_THRESHOLD as score >= 6/10 AND verdict in {"ready", "almost"}; **brycewang-stanford/Auto-Empirical-Research-Skills** uses score >= 6/10 OR verdict contains "accept", "sufficient", "ready for submission". The combined instruction uses the AND form as authoritative.
- **wanshuiyin/Auto-claude-code-research-in-sleep** stores REVIEW_DOC and REVIEW_STATE.json under `review-stage/` with legacy fallbacks; **brycewang-stanford/Auto-Empirical-Research-Skills** stores them in project root. The combined instruction uses `review-stage/` with fallbacks.
- **wanshuiyin/Auto-claude-code-research-in-sleep** allows `Skill` but not `Agent`; **brycewang-stanford/Auto-Empirical-Research-Skills** allows `Agent` but not `Skill`. The combined instruction allows both.
- **wanshuiyin/Auto-claude-code-research-in-sleep** includes an explicit warning not to wrap the skill in `/loop`, `/schedule`, or `CronCreate`; **brycewang-stanford/Auto-Empirical-Research-Skills** omits this warning. The combined instruction includes the warning.