idea2paper

Offload the labour. Steer the science.

Website • Quick Start • Requirements • Pipeline • Agents • Cloud • CLI

idea2paper orchestrates 6 specialized AI agents to turn a research idea into a paper — proposal analysis, literature search, Slurm experiments, LaTeX drafting, and iterative peer review — while you stay in control via CLI, Dashboard, or Telegram.

Give it an idea and a venue. idea2paper handles the rest.

Papers Written by idea2paper

Budget-Constrained Multi-Modal Research Synthesis via Iterative-Deepening Agentic Search
_{Template: EuroMLSys}

HeteroServe: Capability-Weighted Batch Scheduling for Heterogeneous GPU Clusters in LLM Inference
_{Template: ICML}

TierKV: Prefetch-Aware Memory Tiering for KV Cache in LLM Serving
_{Template: NeurIPS}

Quick Start

curl -fsSL https://idea2paper.org/install.sh | bash

The script:

Detects your OS, installs miniforge if missing, builds the ark-base and ark conda envs, pip-installs idea2paper editable into ~/ARK, and installs the OpenHands CLI (the agent runtime, via uv — it bundles its own Python 3.12).
Asks you for Anthropic / OpenAI / Gemini API keys (fill whichever provider(s) you'll use; the Gemini key also powers Deep Research) and an email for dashboard login. Press Enter to skip any.
Installs the dashboard as a systemd --user service on port 9527 (use --no-webapp to opt out).
Prints a one-time magic-link URL for your email — click it once and you're logged into the local dashboard. No SMTP, no Google OAuth.

After that the dashboard at http://localhost:9527 is the primary UX — create projects, set the model, run, monitor. The CLI also works:

ark doctor          # verify install
ark new myproject   # interactive project wizard
ark run  myproject
ark monitor myproject

Re-run ark webapp login <email> anytime for a fresh sign-in link. Full installer flags: website/homepage/install.sh --help.

Start from an Existing PDF

ark new myproject --from-pdf proposal.pdf

idea2paper parses the PDF with PyMuPDF + Claude Haiku, pre-fills the wizard, and kicks off from the extracted spec.

Requirements

Python 3.10+ with pyyaml and PyMuPDF
Agent runtime: OpenHands CLI (installed via uv, bundles its own Python 3.12) — one runtime that drives Claude / GPT / Gemini / any LiteLLM model, selected per project via model in config.yaml
Optional: LaTeX (pdflatex + bibtex), Slurm, google-genai for AI figures

Manual Installation

The fastest path is the one-line installer in Quick Start. It runs the steps below for you and prints onboarding hints. To do it by hand:

# 1. Create the project research-stack template (no idea2paper code in here —
#    each new project clones this env, so it must stay clean).
conda env create -f environment.yml         # Linux (creates "ark-base")
# OR for macOS:
conda env create -f environment-macos.yml   # macOS (creates "ark-base")

# 2. Install idea2paper itself into a SEPARATE env (not ark-base).
conda create -n ark python=3.11 -y
conda activate ark
pip install -e .                    # Core
pip install -e ".[research]"       # + Gemini Deep Research & Nano Banana
pip install -e ".[webapp]"         # + dashboard / systemd service support

# 3. Install the OpenHands CLI (the agent runtime). It is a standalone `uv`
#    tool with its OWN bundled Python 3.12 — NOT a pip dependency — and must be
#    on PATH for the orchestrator subprocess to find it.
pip install uv && uv tool install --python 3.12 openhands

# 4. Verify (checks the openhands runtime is on PATH, keys are present, etc.)
ark doctor

Framework

idea2paper orchestrates three phases — Initialization & Research, Iterative Development, and Iterative Review — coordinated through shared memory, a persistent Goal Anchor re-injected into every agent call to prevent drift, and human-in-the-loop steering via the web dashboard or Telegram.

Pipeline

idea2paper runs three phases in sequence. The Review phase loops until the paper reaches the target score.

Phase	What Happens
Research	5-step pipeline: Setup (conda env) → Analyze Proposal (researcher) → Deep Research (Gemini) → Specialization (researcher) → Bootstrap (skills & citations)
Dev	Iterative experiment cycle: plan → run on Slurm → analyze → write initial draft
Review	Compile → Review → Plan → Execute → Validate, repeating until score ≥ threshold

Review Loop details

Each iteration of the Review phase runs 5 steps:

Step	Description
Compile	LaTeX → PDF, page count, page images
Review	AI reviewer scores 1–10, lists Major & Minor issues
Plan	Planner creates a prioritized action plan
Execute	Researcher + Experimenter run in parallel; Writer revises LaTeX
Validate	Verify changes compile; recompile PDF

The loop repeats until the score reaches the acceptance threshold — or you intervene via Telegram.

Agents

Agent	Role
Researcher	Analyzes the proposal, runs the Gemini-backed literature survey, and specializes agent prompts for the project
Reviewer	Scores the paper against venue standards, generates improvement tasks
Planner	Turns review feedback into a prioritized action plan; analyzes Dev-phase results
Writer	Drafts and refines LaTeX sections with DBLP-verified references
Experimenter	Designs experiments, submits Slurm jobs, analyzes results
Coder	Writes and debugs experiment code and analysis scripts

Guardrails & Step Log

An autonomous run is watched and gated, not a black box.

Live step log. Every agent's actions — each bash command, file edit, and result — stream into the log as they happen (no more 30-minute blank), and into a structured agent_steps.jsonl. Secret values are redacted automatically. Tune detail with log_verbosity: quiet|normal|verbose|debug.
Pause-and-ask before the risky stuff. Before deleting files, launching a burst of jobs, provisioning a paid cloud instance, handling credentials, pushing/exfiltrating data, or crossing a spend cap, idea2paper asks you on Telegram and waits for approval (Approve / Deny / remember-this). It remembers your answer so it doesn't re-ask, denies on timeout, and fails open (auto-allows + logs) when no Telegram is configured — so nothing ever hangs.
Two enforcement layers. Shadow-PATH wrappers gate risky commands before they run; a circuit breaker backstops anything that bypasses them. The orchestrator's own autonomous cloud-provision / git-push / spend actions are gated too — but commands you trigger yourself (ark clear, delete, stop) are not.

Configure it all under the intervention: block in config.example.yaml; the default autonomy level (standard) only interrupts you for genuinely high-stakes actions.

What Sets idea2paper Apart

	Other Tools	idea2paper
Control	Fully autonomous — drifts from intent, no mid-run correction	Human-in-the-loop: pause at key decisions, steer via Telegram or web
Formatting	Broken layouts, LaTeX errors, manual cleanup	Venue templates + sub-page length control to hit page limits exactly
Citations	LLMs fabricate plausible-looking references	API-first BibTeX (DBLP / CrossRef / arXiv) with content–claim alignment
Review	Text-only review of the LaTeX source	Visual-grounded: page images and source, scored against venue standards
Figures	Default styles, wrong sizes, no page awareness	Nano Banana + venue-aware canvas, column widths, and fonts
Isolation	Shared env — projects interfere with each other	Per-project conda env, sandboxed HOME, full multi-tenant isolation
Integrity	LLMs simulate results instead of running real experiments	Anti-simulation prompts + builtin skills enforce real execution

Environment Isolation

Each project runs in its own per-project conda environment, cloned from a base env at project creation. This ensures full multi-tenant isolation:

Sandboxed Python — per-project .env/ directory with its own packages
Isolated HOME — each orchestrator runs with HOME set to the project directory
No cross-contamination — PYTHONNOUSERSITE=1 prevents leaking user-site packages
Automatic provisioning — ark run and the Web Portal detect and use the project conda env; the pipeline bootstraps it if missing

# The conda env is created automatically on first run.
# ark run will detect and use it:
ark run myproject
#   Conda env: /path/to/projects/myproject/.env

Skills System

idea2paper ships with builtin skills — modular instruction sets that agents load at runtime to enforce best practices:

Skill	Purpose
research-integrity	Anti-simulation prompts: agents must run real experiments, not fabricate outputs
human-intervention	Escalation protocol: agents pause and ask via Telegram before irreversible actions
env-isolation	Enforces per-project environment boundaries
runtime-sandbox	Locks each project to its own conda env, `HOME`, and tmp dir at runtime
figure-integrity	Validates figure content matches data; prevents placeholder or hallucinated plots
page-adjustment	Maintains page limits by adjusting content density, not deleting sections

Skills live in skills/builtin/ and are auto-installed during pipeline bootstrap. Domain skills (e.g., HPC) live in skills/library/ and are pulled in by the Researcher when relevant.

CLI Reference

Command	Description
`ark new <name>`	Create project via interactive wizard
`ark run <name>`	Launch the pipeline (auto-detects per-project conda env)
`ark status [name]`	Score, iteration, phase, cost
`ark monitor <name>`	Live dashboard: agent activity, score trend
`ark update <name>`	Inject a mid-run instruction
`ark stop <name>`	Gracefully stop
`ark restart <name>`	Stop + restart
`ark research <name>`	Run Gemini Deep Research standalone
`ark config <name> [key] [val]`	View or edit config
`ark clear <name>`	Reset state for a fresh start
`ark delete <name>`	Remove project entirely
`ark setup-bot`	Configure Telegram bot
`ark list`	List all projects with status
`ark doctor`	Diagnose a self-host install (envs, API keys, webapp)
`ark cite-check <name>`	Verify project citations against DBLP / CrossRef
`ark cite-search <query>`	Search academic databases for papers
`ark webapp install`	Install web dashboard service
`ark access {list,add,remove,add-domain,remove-domain}`	Manage Dashboard Cloudflare Access allowlist

Dashboard

idea2paper includes a web-based dashboard for managing projects, viewing scores, and steering agents. The dashboard shows live phase badges (Research / Dev / Review), per-project conda env status, and real-time cost tracking. It is served from a single FastAPI process that also hosts the homepage — one port, one systemd unit.

Configuration

Configured via .ark/webapp.env (auto-created on first ark webapp run). Set SMTP_* for magic-link login, ALLOWED_EMAILS / EMAIL_DOMAINS to restrict access, and optionally GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET for Google OAuth.

Management Commands

Command	Description
`ark webapp`	Start the dashboard in the foreground (useful for debugging).
`ark webapp release`	Tag the current code and deploy to the production worktree.
`ark webapp install [--dev]`	Install and start as a `systemd` user service.
`ark webapp status`	Show status of the systemd service.
`ark webapp restart`	Restart the dashboard service.
`ark webapp logs [-f]`	View or tail service logs.

Service Details (Prod vs. Dev)

	Prod	Dev
Port	9527	1027
Service Name	`ark-webapp`	`ark-webapp-dev`
Conda Env	`ark-prod`	`ark-dev`
Code Source	`~/.ark/prod/` (pinned)	Current repository (live)

Team Deployment (shared prod)

A team can serve one production instance from a shared, group-writable directory while every member develops in their own clone and releases with a single command. Set in each member's shell rc:

export ARK_RELEASE_ROOT=/shared/path/ARK    # shared checkout: prod worktree, DB, projects
export ARK_CONDA_ROOT=/shared/path/conda    # shared conda (ark-prod / ark-base envs)
export ARK_TOOLS_BIN=/shared/path/tools/bin # shared OpenHands CLI
umask 002                                   # keep new files group-writable

With these set, ark webapp release from any member's clone tags the release, pushes the tag, updates the shared prod worktree, and installs into the shared env; the running webapp notices the new .deployed-tag marker and recycles itself within ~30s — no service ownership needed. ark webapp install bakes the shared paths (and the shared DB under $ARK_RELEASE_ROOT/.ark/data) into the generated unit.

Direct orchestrator invocation

python -m ark.orchestrator --project myproject --mode paper --max-iterations 20
python -m ark.orchestrator --project myproject --mode dev

Docker Usage

[!IMPORTANT] The idea2paper research runtime depends on scientific libraries that are most stable on x86_64. If you are building on an Apple Silicon (M1/M2/M3) Mac, you must build for the linux/amd64 platform.

All idea2paper Dockerfiles and the docker-compose.yml are configured to force linux/amd64 by default.

Running with Docker Compose

# Start the web portal (builds the image automatically for amd64)
docker compose -f docker/docker-compose.yml up --build -d

The web portal will be accessible at http://localhost:9527. All databases, configurations, and project data are persisted in a Docker named volume (ark_data).

docker compose -f docker/docker-compose.yml logs -f webapp

Configuration

cp .ark/webapp.env.example .ark/webapp.env
# Edit .ark/webapp.env with your credentials

Then uncomment the environment volume mapping in docker/docker-compose.yml under the webapp service:

      - ../.ark/webapp.env:/data/.ark/webapp.env:ro

Running Individual Jobs

Uncomment the job service in docker/docker-compose.yml, then run:

docker compose -f docker/docker-compose.yml run --rm job \
  --project myproject \
  --project-dir /data/projects/<user-id>/myproject \
  --mode research \
  --iterations 10

Pass required API keys (e.g., ANTHROPIC_API_KEY, GEMINI_API_KEY) as environment variables.

Running Standalone Containers

# Build images (force amd64)
docker build --platform linux/amd64 -f docker/Dockerfile.webapp -t ark-webapp .
docker build --platform linux/amd64 -f docker/Dockerfile.job -t ark-job .

# Run the Web Portal
docker run -d --name ark-webapp \
  --platform linux/amd64 \
  -p 9527:9527 \
  -v ark_data:/data \
  ark-webapp

# Run a Research Job
docker run --rm -it \
  --platform linux/amd64 \
  -v ark_data:/data \
  -e ANTHROPIC_API_KEY="sk-ant-..." \
  ark-job \
  --project myproject \
  --project-dir /data/projects/myproject \
  --mode research

Pushing to GCP

# Push to Artifact Registry (recommended)
./docker/push-gcp.sh --project [PROJECT_ID] --region [REGION] --repo [REPO] --build

# Push to Legacy Container Registry (gcr.io)
./docker/push-gcp.sh --project [PROJECT_ID] --legacy --build

The --build flag automatically builds the images for linux/amd64 even when running on macOS.

Cloud Compute

idea2paper's v2 cloud architecture decouples the Control Plane from the Execution Plane, enabling the full orchestrator to run on a remote cloud VM while you interact with a lightweight local webapp.

How it works:

The local webapp (or CLI) acts as a lightweight launcher — it provisions a remote Orchestrator VM, syncs your project code and API keys over SSH, and triggers the orchestrator process.
The Orchestrator VM runs all high-level logic (Researcher, Planner, Writer, LaTeX, figures) remotely in a detached session.
Experiments can run on the same orchestrator VM or on a separate GPU VM (configurable independently).
The webapp streams logs and syncs state back periodically. The orchestrator VM self-terminates when the run completes.

Tip

Cloud credentials are encrypted at rest using your SECRET_KEY. Your keys are never logged or transmitted to third parties.

Configuration Hierarchy

idea2paper uses a three-tier configuration model for cloud compute:

System Defaults: Set in webapp.env (e.g., CLOUD_REGION, CLOUD_NETWORK).
Global User Defaults: Set in the Settings panel (⚙️). These apply to all your projects.
Project Overrides: Set during project creation or restart. These have the highest priority.

This hierarchy lets you define standard machine types and VPC settings once, while easily swapping to a powerful GPU instance for a specific experiment.

Enabling Cloud Compute via the Dashboard

Open the Settings panel (⚙️ icon in the top navigation bar).
Scroll down to the Cloud Compute section.
Enter your credentials for your preferred provider (GCP, AWS, or Azure).
Click Save.

When creating a new project you can now independently select:

Orchestrator Backend — cloud (GCP) to run the control plane remotely, or local to run it on the same machine as the webapp.
Experiment Backend — cloud (GCP/AWS/Azure) for GPU experiments, or local to run them on the Orchestrator VM itself.

Creating a Project

Once cloud compute is configured, launch a project through the dashboard:

Click New Project from the dashboard home.
Fill in the research goal, target venue, and any additional instructions.
Click Submit — the webapp generates a config.yaml, provisions the Orchestrator VM, syncs your project, and starts the run.

The generated config.yaml is stored at:

~/.ark/data/projects/<user_id>/<project_id>/config.yaml

You can inspect or hand-edit this file at any time (e.g., to tune instance type or add setup_commands). Changes take effect on the next run or restart.

[!NOTE] If PROJECTS_ROOT is set in your .ark/webapp.env, the path above is replaced by $PROJECTS_ROOT/<user_id>/<project_id>/config.yaml.

Cloud Provider Setup

☁️ Google Cloud Platform (GCP)

1. Create a Service Account

export PROJECT_ID=your-gcp-project-id

# Create a service account for idea2paper
gcloud iam service-accounts create ark-runner \
  --display-name="ARK Research Runner"

# Grant required roles (Compute Admin + Service Account User)
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:ark-runner@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/compute.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:ark-runner@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/iam.serviceAccountUser"

# Download the JSON key
gcloud iam service-accounts keys create ~/ark-gcp-key.json \
  --iam-account=ark-runner@${PROJECT_ID}.iam.gserviceaccount.com

2. Enable Required APIs

gcloud services enable compute.googleapis.com --project=$PROJECT_ID

3. Build the Machine Image

idea2paper uses a pre-baked Machine Image containing all system dependencies (Conda, LaTeX, Node.js) for fast boot times. Build it once:

./scripts/build_ark_gcp_image.sh [GCP_PROJECT_ID] [ZONE]

This script spins up a temporary VM, installs TeX Live, Miniforge, Node.js, and the ark-base environment, then saves a Machine Image named ark-job-v1-[timestamp] tagged with the ark-job family.

4. Configure in Dashboard

Paste the contents of ~/ark-gcp-key.json into the GCP Service Account JSON field and set your GCP Project ID in the Settings panel.

5. Finding GCP Parameters (Optional)

# List available zones
gcloud compute zones list

# List available machine types in a specific zone
gcloud compute machine-types list --zones=us-central1-a

# List networks and subnets
gcloud compute networks list
gcloud compute networks subnets list --regions=us-central1

Alternatively, use the Google Cloud Console:

Zones/Machine Types: Compute Engine → VM Instances → Create Instance
Networks: VPC Network → VPC Networks
Images: Compute Engine → Images

6. `config.yaml` Reference (advanced / CLI only)

The webapp generates this automatically from your Settings. For manual or CLI-driven projects, see config.example.yaml for the full template. The model + keys (all agents run through OpenHands → LiteLLM):

model: anthropic/claude-sonnet-4-6     # agents run this — any LiteLLM model
                                       # (gemini/… , openai/… , deepseek/… , …)
bot_model: anthropic/claude-haiku-4-5  # cheap model for light helpers (titles, summaries)
anthropic_api_key: "sk-ant-..."        # fill the provider(s) you use — the model
openai_api_key:    "sk-..."            #   prefix picks which key is used
gemini_api_key:    "..."               # gemini key also powers Deep Research (optional)

Compute uses two backends (orchestrator VM + experiment VM):

# Orchestrator VM: runs Researcher, Planner, Writer, LaTeX (no GPU needed)
orchestrator_compute_backend:
  type: cloud
  provider: gcp
  region: us-central1-a
  instance_type: n1-standard-2
  image_family: ark-job              # Pre-baked idea2paper image

# Experiment VM: runs GPU-intensive workloads
experiment_compute_backend:
  type: cloud
  provider: gcp
  region: us-central1-a
  instance_type: g2-standard-4
  accelerator_type: nvidia-l4
  accelerator_count: 1
  # Optional: post-boot setup
  setup_commands:
    - conda activate base && pip install -r requirements.txt

To run experiments on the Orchestrator VM instead of a separate instance, set experiment_compute_backend.type: local.

☁️ Amazon Web Services (AWS)

1. Create an IAM User

# Create an IAM user for idea2paper
aws iam create-user --user-name ark-runner

# Attach policy (EC2 full access is sufficient)
aws iam attach-user-policy \
  --user-name ark-runner \
  --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess

# Create access keys
aws iam create-access-key --user-name ark-runner
# Note the AccessKeyId and SecretAccessKey from the output

2. Create an SSH Key Pair

# Create a key pair and save locally
aws ec2 create-key-pair \
  --key-name ark-key \
  --query 'KeyMaterial' \
  --output text > ~/.ssh/ark-key.pem
chmod 600 ~/.ssh/ark-key.pem

3. Configure in Dashboard

Enter your AWS Access Key ID, AWS Secret Access Key, and AWS Region (e.g., us-east-1) in the Settings panel.

4. `config.yaml` Reference (advanced / CLI only)

experiment_compute_backend:
  type: cloud
  provider: aws
  region: us-east-1
  instance_type: g4dn.xlarge        # 1x T4 GPU, 4 vCPUs, 16 GB RAM
  image_id: ami-0c7c51e8edb7b66d3   # Deep Learning AMI (Ubuntu 22.04)
  ssh_key_name: ark-key              # Key pair name in AWS Console
  ssh_key_path: ~/.ssh/ark-key.pem
  ssh_user: ubuntu
  security_group: sg-xxxxxxxx        # Must allow inbound SSH (port 22)
  setup_commands:
    - conda activate pytorch && pip install -r requirements.txt

[!IMPORTANT] Ensure your security group allows inbound SSH (port 22) from the IP of the machine running the webapp. Without this, idea2paper cannot connect to the provisioned instance.

☁️ Microsoft Azure

1. Create a Service Principal

# Login
az login

# Create a service principal with Contributor role
az ad sp create-for-rbac \
  --name "ark-runner" \
  --role Contributor \
  --scopes /subscriptions/YOUR_SUBSCRIPTION_ID
# Note: appId (Client ID), password (Client Secret), and tenant (Tenant ID)

2. Register the SSH Public Key

# Generate an SSH key if you don't have one
ssh-keygen -t rsa -b 4096 -f ~/.ssh/ark-azure-key

# The public key (~/.ssh/ark-azure-key.pub) will be used automatically

3. Configure in Dashboard

Enter your Azure Client ID, Azure Client Secret, Azure Tenant ID, and Azure Subscription ID in the Settings panel.

4. `config.yaml` Reference (advanced / CLI only)

experiment_compute_backend:
  type: cloud
  provider: azure
  region: eastus                     # Azure location
  instance_type: Standard_NC6s_v3    # 1x V100 GPU, 6 vCPUs, 112 GB RAM
  image_id: UbuntuLTS                # OS image alias
  ssh_key_path: ~/.ssh/ark-azure-key
  ssh_user: azureuser
  resource_group: ark-resources      # Will be created if it doesn't exist
  setup_commands:
    - pip install -r requirements.txt

Log Streaming & Re-attachment

Log Streaming — the Orchestrator VM maintains a logs/latest.log symlink; the webapp polls it periodically to show live progress.
State Sync — every 60 seconds, the launcher pulls the auto_research/ state directory back from the VM to update the Dashboard UI.
Re-attachment — if you restart your local webapp, idea2paper detects the existing orchestrator_instance.yaml, probes the remote VM via SSH, and re-attaches to the running process without re-provisioning.

Cost Control

[!WARNING] Cloud VMs are billed by the hour. idea2paper includes several safeguards to prevent runaway costs:

Launcher Heartbeat — every time the webapp polls the VM for state, it touches a launcher_heartbeat file on the remote VM.

VM Reaper — a background daemon (ark_vm_reaper.sh) runs on the Orchestrator VM. If the orchestrator process finishes and the launcher heartbeat is stale for >30 minutes, the VM automatically shuts itself down.

Manual Stop — clicking Stop in the dashboard performs a final sync of all results and then terminates the GCP instance.

If the webapp process is killed unexpectedly, the VM Reaper will self-terminate after the heartbeat timeout. Always verify no stray instances are running in your cloud console after unexpected shutdowns. Check reaper.log in the remote project directory if a VM shuts down unexpectedly.

Telegram Integration

ark setup-bot    # one-time: paste BotFather token, auto-detect chat ID

What you get:

Rich notifications — formatted score changes, phase transitions, agent activity, and errors
Send instructions — steer the current iteration in real time
Request PDFs — latest compiled paper sent to chat
Human intervention — agents escalate decisions to you before irreversible actions
HPC-friendly — handles self-signed SSL certificates on enterprise/HPC networks

Supported Venues

LaTeX templates ship for NeurIPS, ICML, ICLR, AAAI, MLSys, the ACL family (ACL / EMNLP / NAACL / EACL / AACL / COLING), the CVF family (CVPR / ICCV / WACV), the ACM acmart family (SOSP / EuroSys / ASPLOS / EuroMLSys), the USENIX family (OSDI / NSDI / ATC / FAST / Security), and IEEE / IEEEtran (INFOCOM and other IEEE venues) — all from official 2026 style files (MLSys reuses its unchanged 2025 kit) — plus a generic article fallback for TMLR, workshops, and technical reports. Custom templates are still accepted: idea2paper scans .tex / .aux / .sty to learn the layout, fixes compile errors, and enforces the venue page limit.

Community

微信交流群 / Join our WeChat group

_{The WeChat group QR refreshes periodically — open an issue if it has expired.}

License

Apache 2.0

Name		Name	Last commit message	Last commit date
Latest commit History 547 Commits
.github		.github
ark		ark
assets		assets
deploy/systemd		deploy/systemd
docker		docker
scripts		scripts
skills		skills
submodules		submodules
test_fixtures/cheap_run		test_fixtures/cheap_run
tests		tests
venue_templates		venue_templates
website		website
.dockerignore		.dockerignore
.gitignore		.gitignore
.gitmodules		.gitmodules
ARCHITECTURE.md		ARCHITECTURE.md
ARCHITECTURE_ar.md		ARCHITECTURE_ar.md
ARCHITECTURE_zh.md		ARCHITECTURE_zh.md
LICENSE		LICENSE
README.md		README.md
README_ar.md		README_ar.md
README_zh.md		README_zh.md
TODO.md		TODO.md
TODO_ar.md		TODO_ar.md
TODO_zh.md		TODO_zh.md
config.example.yaml		config.example.yaml
environment-macos.yml		environment-macos.yml
environment.yml		environment.yml
pyproject.toml		pyproject.toml
setup.py		setup.py

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

idea2paper

Papers Written by idea2paper

Quick Start

Start from an Existing PDF

Requirements

Framework

Pipeline

Agents

Guardrails & Step Log

What Sets idea2paper Apart

CLI Reference

Dashboard

Configuration

Management Commands

Team Deployment (shared prod)

Cloud Compute

Enabling Cloud Compute via the Dashboard

Cloud Provider Setup

1. Create a Service Account

2. Enable Required APIs

3. Build the Machine Image

4. Configure in Dashboard

5. Finding GCP Parameters (Optional)

6. config.yaml Reference (advanced / CLI only)

1. Create an IAM User

2. Create an SSH Key Pair

3. Configure in Dashboard

4. config.yaml Reference (advanced / CLI only)

1. Create a Service Principal

2. Register the SSH Public Key

3. Configure in Dashboard

4. config.yaml Reference (advanced / CLI only)

Supported Venues

Community

License

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 4

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

6. `config.yaml` Reference (advanced / CLI only)

4. `config.yaml` Reference (advanced / CLI only)

4. `config.yaml` Reference (advanced / CLI only)

Packages