AtomLane

Parallelize only what is proven safe.

Safe parallel execution for coding agents: AtomLane makes Codex finish builds, tests, Docker, and research pipelines faster on macOS without breaking task semantics.

中文说明 · Live report · Report first run · Share a benchmark

Install in two commands

codex plugin marketplace add cloudguo123/atomlane
codex plugin add mac-parallel-accelerator@mac-parallel-accelerator

mac-parallel-accelerator remains the technical plugin ID during the AtomLane brand migration, so existing installs and links keep working.

Open a new Codex task, then ask:

Use $accelerate-local-work to inspect this project and run the safe parts in parallel.
Keep progress visible and report time saved for this run and cumulatively.

Requirements: macOS, Codex with plugin and MCP support, and Python 3.10+. Ruby is only needed for Compose YAML analysis; Node.js 20+ is only needed to rebuild the browser indicator.

The repository also conforms to the vendor-neutral Agent Plugins 1.0.0 package layout through its root plugin.json, skills/, and local-stdio mcp.json. Codex-native clients continue to use .codex-plugin/plugin.json and .mcp.json.

Related MCP server: claude-code-codex-agents

Why this exists

Most “parallel” wrappers split command text and hope for the best. That can reorder &&/||, race .next, JUnit, database, Docker volume, or Git state, multiply nested worker pools, and hide failures until the end.

AtomLane first compiles the requested work into a typed Atom IR. Only atoms proven independent are admitted concurrently. Unknown effects, ambiguous writers, stale source snapshots, unsupported lifecycle events, and changed plans fail closed.

shell · package scripts · Make · Compose · tests · builds · declared work
                              │
                              ▼
             static frontends → typed Atom IR
                              │
                              ▼
        conflict checks → resource-aware event scheduler
                              │
                              ▼
              exact verified execution + live savings

What it accelerates

The scenario catalog includes more than 50 presets covering software, research, containers, media, ML, release, database, and low-level CPU/GPU/I/O work.

Live execution—not a blank spinner

Long runs use a PTY-backed runner and continuously show:

elapsed 2m 15s · running 4 · ready 2 · completed 7 · failed 0
estimated saved this run 4m 31s · cumulative saved 19m 52s

At completion, every atom's status, return code, timeout, skip reason, output truncation, peak concurrency, per-run savings, and cumulative savings are checked.

Five-minute benchmark

The retained public run executed four isolated low-load workloads through the real parallel executor. Every task ran for at least five minutes.

The serial equivalent is the sum of the observed independent task runtimes; it is not a separately executed serial run. This demonstrates scheduler overhead and reporting behavior under controlled independent work, not a universal claim that every project will be 4× faster. See the visual report, raw evidence, and benchmark protocol.

Execution contract

The safety handshake is deliberately strict:

atomic_task_plan
  → complete immutable compiled_plan + plan_hash
  → atomic_exec with that exact object and hash

Plans are not translated back into hand-written waves or generic DAG calls. Typed control edges distinguish success, failure, order, data, stream, readiness, health, completion, and cleanup. Artifacts, non-file effects, capacity resources, lifecycle events, and source snapshots remain part of the execution contract.

Privacy and authorization

• Project and optional trace inspection are local and bounded.

• Trace analysis returns aggregate routing signals—not prompts, reasoning, command bodies, or tool outputs.

• Parallelism changes timing, never permission. Planning does not authorize new commands, remote mutations, destructive cleanup, or retries.

• No run result is uploaded automatically. Sharing is explicit and reviewable.

• Timeouts terminate process groups; timed-out side effects are treated as unknown and are not automatically retried.

Read SECURITY.md for the threat model and reporting process.

Development

python3 -m py_compile scripts/*.py
python3 -m unittest discover -s scripts -p 'test*.py' -v
python3 scripts/self_test.py
uvx ruff check scripts
npm ci && npm run build:indicator

Generate public verification and sharing assets:

python3 scripts/generate_test_report.py
python3 scripts/generate_growth_assets.py
python3 scripts/render_growth_media.py  # optional PNG/GIF, requires Chrome + ffmpeg

Useful references:

• Architecture and safety invariants

• Atom IR reference

• Benchmark and external-result protocol

• Brand and compatibility guide

• Contributing

• Release history

Help it grow

Try it on one real task, then share the sanitized result card or submit a benchmark. If the planner blocks work that should be safe, that report is just as valuable as a speedup—it identifies the next missing semantic rule.

Report your first run · Open a benchmark report · Ask a question · View the roadmap

MIT licensed · Privacy · Terms