# Omega Publication Pipeline: Multi-Agent Automated Scientific Review and Improvement

> **Skill for Claw** — Executable multi-agent pipeline that takes a LaTeX manuscript
> through iterative review and fix cycles using three AI systems (Claude, ChatGPT, Codex)
> until it reaches journal acceptance standard.

## Overview

This skill orchestrates a complete publication pipeline where multiple AI agents
collaborate with distinct roles: Codex performs initial review and bulk fixes,
ChatGPT serves as an independent validation oracle (hard acceptance gate), and
Claude orchestrates the workflow and performs deep mathematical verification.
The pipeline has been validated on 17+ mathematics papers across 5+ subfields.

## Prerequisites

- Python 3.9+
- Git
- Chrome browser with Tampermonkey extension
- ChatGPT Pro subscription (logged in at chatgpt.com)
- Claude Code CLI
- Access to OpenAI Codex

## Step 1 — Clone the repository

```bash
git clone https://github.com/the-omega-institute/automath.git
cd automath/papers/publication
```

## Step 2 — Start the Oracle Server

The Oracle Server bridges AI agents to ChatGPT via a Tampermonkey userscript
running inside the browser (invisible to Cloudflare).

```bash
python oracle_server.py
# Output: [server] Oracle server running on http://localhost:8765
```

Keep this terminal running.

## Step 3 — Install the Tampermonkey Bridge

1. Open Chrome -> Tampermonkey Dashboard -> Create new script
2. Paste contents of `chatgpt_oracle.user.js`
3. Save (Ctrl+S)
4. Open https://chatgpt.com — verify the dark "Oracle Bridge" panel appears

## Step 4 — Test the Oracle Bridge

```bash
python oracle_dispatch.py --prompt-text "What is 2+2? Reply with just the number." --name test_task --wait
```

Verify: Chrome shows ChatGPT receiving and answering the prompt automatically.

## Step 5 — Run the Publication Pipeline on a Paper

### 5a. Codex General Review + Self-Fix (Round 1)

```bash
python codex_fix.py --paper 2026_<paper_slug>/ --review-text "
Perform a general editorial review. Check:
1. Mathematical correctness of all theorems and proofs
2. Bibliography completeness
3. Cross-references all resolve
4. No orphaned files
5. No revision-trace language
Fix every issue you find."
```

### 5b. Codex Targeted Review + Fix (Round 2)

```bash
python codex_fix.py --paper 2026_<paper_slug>/ --review-text "
Perform a targeted review for [TARGET_JOURNAL]. Check:
1. Writing style matches journal conventions
2. Novelty clearly stated
3. Related work covers relevant literature
4. Every statement has a proof
Fix every issue you find."
```

### 5c. ChatGPT Editorial Review (Independent Validation)

```bash
python oracle_dispatch.py --paper 2026_<paper_slug>/ --task editorial_review --wait
```

Output saved to `oracle/done/<task_id>.md`.

### 5d. Codex Fix from ChatGPT Feedback

```bash
python codex_fix.py --paper 2026_<paper_slug>/ --review oracle/done/<review_file>.md
```

### 5e. Claude Deep Mathematical Verification

Launch Claude Code with the pub-editorial agent for deep review.

### 5f. ChatGPT Acceptance Gate (HARD GATE)

```bash
python oracle_dispatch.py --paper 2026_<paper_slug>/ --task acceptance_gate --wait --model o3-mini-high
```

If ACCEPT -> proceed to backflow. If not -> return to Step 5d with new feedback.

## Step 6 — Backflow: Feed Results Back to Core Theory

```bash
python backflow.py scan     # Extract claims from ACCEPT papers
python backflow.py report   # Generate backflow report
python backflow.py inject --execute  # Inject cross-refs into core theory
```

## Step 7 — Verify Pipeline Quality

```bash
python pub_check.py 2026_<paper_slug>/ --stage P7
```

Checks: citation completeness, cross-references, file size, style, proof completeness,
abstract word count, MSC codes, PIPELINE.md format.

## Expected Pipeline Statistics

From our production run on 17 papers:
- 911 claims extracted across all papers
- 6 papers reached ACCEPT status
- 9 papers submitted to journals
- Average 5+ review-fix rounds per paper
- 3 core theory sections enriched via backflow

## Architecture

```
Core Theory -> research_cycle.py -> Papers -> Four-Gate Pipeline -> backflow.py -> Core
                                       |
                   Gate 1: Codex review+fix (2 rounds)
                   Gate 2: ChatGPT review -> Codex fix
                   Gate 3: Claude deep review -> Codex fix
                   Gate 4: ChatGPT acceptance gate (HARD)
```

## Key Design Principles

1. **Codex does the heavy lifting** (cheapest per fix, 2-3 rounds per paper)
2. **ChatGPT validates independently** (free via web, different model catches different issues)
3. **Claude orchestrates** (deep math verification, pipeline coordination)
4. **Rotate reviewers** for diverse perspectives on each paper
5. **Minimum 5 rounds** before marking ready for submission

## Troubleshooting

- Oracle panel shows "Server unreachable": start oracle_server.py
- PDF upload fails: refresh chatgpt.com, check Tampermonkey is enabled
- Codex timeout: increase --timeout flag, check API quota
- Task stuck: check oracle/done/ for completed results

## Citation

Zhang, W. et al. (2026). Omega Publication Pipeline.
https://github.com/the-omega-institute/automath