API keys or supported subscriptions
The Verifiable Coding Agent Runtime.
Run verifiable engineering loops with control, alignment, and confidence.
Define stages, checks, gates, tools, artifacts, and approvals. Atomic executes the workflow and preserves inspectable evidence from the run.
ATOMIC
ready / --
ready
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 workflow in natural language and let Atomic create it, or define and version it directly with the TypeScript workflow SDK. Compare the built-in workflow examples to see the controls Atomic currently ships.
Explore dynamic coding agent workflows, read how the runtime, loops, and workflows fit together, or use the guide to verification for coding agents.
define
Define the process.
Name the stages, tools, prompts, checks, artifacts, gates, and approvals the agent must follow.
execute
Run it on Atomic.
Atomic tracks each stage, scopes its instructions and context, runs defined checks, and pauses for human input where the workflow requires it.
verify
Inspect the evidence.
Workflows can preserve diffs, check output, reviewer notes, logs, and other artifacts needed for review.
Verification is built into the runtime.
Workflows define checks, evidence, gates, and approvals. Atomic executes and tracks those controls as part of the run, while the runtime materializes an inspectable directed acyclic graph (DAG) of sequential, parallel, and nested stages.
See how workflow graphs execute ATOMIC CHAT
↵ send
›
ship-feature.workflow.ts
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
2 2 1
planner 2.1s
build 12.4s
gpt-5.5 review 8.7s
opus 4.8 review 6.2s
ship pending
GRAPH
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, subagents, and TypeScript extensions.
CLIs, MCP, web access, or custom tools
Pull issues, route follow-ups, post summaries
Use the CLIs already installed in your workspace
Investigate incidents with traces, logs, and state
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.
Use Atomic for repeatable agent systems with real done criteria.
These are examples of loops Atomic can power when work needs explicit controls and inspectable evidence.
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.
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.
Verifiability is runtime behavior. Atomic defines what runs, what context each stage receives, what it must produce, which checks allow progress, and where humans approve. Artifacts make that enforced process auditable.
A verifiable run can combine bounded workflow stages, evidence artifacts and receipts, schema-validated handoffs, fresh-context reviewer passes, reducer-enforced outcomes, executable validation before approval, and resumable checkpoints. The workflow defines which controls it uses; the selected model still generates the code and text. Confidence comes from runtime-enforced structure, evidence, and review. Read the practical guide to verification for coding agents.
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.