The Verifiable Coding Agent Runtime.

Run verifiable engineering loops with control, alignment, and confidence.

Define stages, checks, gates, tools, artifacts, and approvals. Atomic enforces the process and leaves every run with auditable artifacts.

$ npm install -g @bastani/atomic

Star on GitHub ★ 260 Workflow docs

ATOMIC

● live

runtime, loops, workflows

Runtime first. Loops on top.

Atomic is the runtime. Loops are the repeatable agent systems you build on it. Workflows are how Atomic makes loops executable: stages, tools, prompts, checks, artifacts, gates, and approvals.

Describe a loop in natural language or define it as a workflow in TypeScript. Atomic runs that loop as one controlled run and makes the work verifiable by design.

define

Define the process.

Name the stages, tools, prompts, checks, artifacts, gates, and approvals the agent must follow.

execute

Run it on Atomic.

Atomic bounds each stage, scopes instructions and context, enforces checks, and pauses for human approval when required.

verify

Inspect auditable artifacts.

Every run leaves the diff, check output, reviewer notes, logs, and artifacts needed to trust the result.

See a verifiable run end to end

how it works

Workflows make loops executable.

Put the process in a file. Review it, version it, and run it from the repo with scoped stages, checks, gates, tools, artifacts, and approvals.

Read workflow file syntax

ATOMIC CHAT workflow-creator

↵ send

describe a spec-driven workflow:

›

ship-feature.workflow.ts @bastani/atomic

import { workflow } from "@bastani/workflows";
import { Type } from "typebox";

export default workflow({
  name: "ship-feature",
  description: "Plan, build, and gate with dual reviewers.",
  inputs: {
    task: Type.String({ description: "Feature or fix to ship." }),
  },
  outputs: {
    result: Type.String({ description: "Implementation summary." }),
  },
  run: async (ctx) => {
    const planPath = ".atomic/workflows/runs/ship-feature/plan.md";

    await ctx.task("planner", {
      prompt: `Create a concise plan for: ${String(ctx.inputs.task)}`,
      output: planPath,
    });

    const result = await ctx.task("build", {
      prompt: [
        `Plan artifact: ${planPath}`,
        "Read it, implement it, then run tests and lint.",
      ].join("\n"),
      reads: [planPath],
    });

    await ctx.parallel([
      {
        name: "review-gpt-5.5",
        prompt: "Review the final diff before PR handoff.",
        model: "openai/gpt-5.5:xhigh",
      },
      {
        name: "review-opus-4.8",
        prompt: "Review the final diff before PR handoff.",
        model: "github-copilot/claude-opus-4.8 (1m):xhigh",
      },
    ], { concurrency: 2, failFast: false });

    if (await ctx.ui.confirm(`Open PR?\n\n${result.text}`)) {
      await ctx.task("ship", { prompt: "Open a draft PR" });
    }

    return { result: result.text };
  },
});

Orchestrator ship-feature

✓ 2 ● 2 ○ 1

planner 2.1s

build 12.4s

gpt-5.5 review 8.7s

opus 4.8 review 6.2s

ship pending

GRAPH

↑↓←→ navigate ↵ attach / stages ctrl+b d detach q quit

verifiable by design

Verifiability is enforced runtime structure plus auditable artifacts.

Ask Atomic chat for status during a run, or inspect the artifacts and gates when it stops.

scoped stageshandoffsauditable artifactschecksreview gateshuman approvals

connect your tools

A run can use the tools your repo already has.

Atomic is not a closed integration catalog. Runtime-enforced workflows can use CLIs, MCP servers, APIs, scripts, skills, sub-agents, and TypeScript extensions.

Models

API keys or supported subscriptions

Code + reviews

CLIs, MCP, web access, or custom tools

Tickets + chat

Pull issues, route follow-ups, post summaries

Build + runtime

Use the CLIs already installed in your workspace

Observability + data

Investigate incidents with traces, logs, and state

UI validation

Drive browsers, record proof, and check flows

CLIs + scripts

Use gh, docker, kubectl, test runners, and project scripts.

MCP servers

Attach authenticated systems without baking them into the core runtime.

Skills + agents

Load focused expertise for research, debugging, tests, UI work, and review.

Extensions

Drop TypeScript under .atomic/extensions/ to add tools, providers, commands, and UI.

Atomic can power

Use Atomic for repeatable agent systems with real done criteria.

These are the loops teams run on Atomic when they need control, alignment, confidence, and proof from every run.

Coding loops

/workflow ralph

research → plan → implement → test → review → ship

Research, plan, implement, test, review, and ship with scoped stages, enforced checks, and auditable artifacts.

Auto-research loops

deep-research-codebase

context → fan out → analyze → synthesize → report

Gather context, fan out analysis, synthesize findings, and write reports that can be inspected later.

Developer assistant loops

team assistant

memory → tools → checkpoint → approval

Run recurring tasks with memory, tools, checkpoints, and approval instead of re-prompting the same process.

Issue triage loops

triage workflow

classify → reproduce → dedupe → route → prioritize → draft fix

Classify, reproduce, deduplicate, route, prioritize, and draft fixes with review gates before handoff.

Content and research pipelines

publish workflow

sources → analyze → draft → review → publish

Collect sources, analyze, draft, review, and publish while preserving artifacts and approvals.

Internal ops agents

ops workflow

request → runbook → tools → logs → approval

Run repeatable internal processes with controlled tools, approvals, logs, and a clear audit trail.

Engineering automation

automation workflow

migrate → release → qa → docs → incident → compliance

Automate migrations, release prep, QA, docs, incidents, and compliance with runtime-enforced process.

Custom agent products

atomic SDK

runtime → SDK → tools → workflows

Build products on Atomic’s runtime, SDK, tools, and workflows when your agent needs verifiable execution.

Define the process. Run verifiable agent work.

Install once, run atomic in a repo, then sign in with /login or an API key. Use /atomic for setup, or /workflow ralph for feature work that needs a spec, checks, auditable artifacts, and a review gate.

View source Open docs

faq

Frequently asked questions.

Atomic is the verifiable coding agent runtime. It runs controlled, instruction-following agent work with scoped stages, checks, artifacts, checkpoints, subagents, review gates, and human approvals. Quick interactive tools are still the right fit for one-off edits.

Use those for quick interactive sessions. Use Atomic when the work needs a runtime-enforced process: repeatable stages, saved artifacts, tests, lint, reviewer passes, approvals, and a review gate before handoff.

Markdown documents the process. Atomic runs it: stages, inputs, tools, prompts, checks, artifacts, gates, approvals, and handoffs are part of the run instead of another checklist the agent has to remember.

Atomic makes the workflow structure explicit and repeatable. The selected model still generates the code and text, so model output itself can vary; trust comes from enforced structure, evidence, and review.

Open Atomic chat and ask for the workflow status. Atomic can summarize the current stage, progress so far, artifacts, token usage, estimated cost, logs, failures, and anything waiting on you.

Atomic is built around repo workflows: specs, research, plans, branches, diffs, tests, lint, auditable artifacts, reviewers, gates, and workflow files instead of a generic agent graph you have to adapt to coding work.

Still evaluating? Read the workflow docs