Autonomous executor · online
Atrium
You state the goal. It ships the result.
Atrium doesn't return plans or reports about work. It writes and deploys code, drives a real browser, and calls real tools -- then comes back with something finished, independently verified, and live.
What Atrium is
An executor, not an assistant that talks about executing
Atrium is an autonomous executor. Give it a goal in plain language -- build this, ship that, fix this bug, find out this fact -- and it finishes the work in the real world, end to end.
It writes and deploys code. It drives a real browser to click through real websites. It calls real tools: file systems, APIs, terminals, deploy pipelines. It doesn't hand you a plan and stop; it doesn't summarize what it would do. It does the thing, then shows you the finished, live artifact.
- Not a chatbot -- it isn't built to hold a conversation, it's built to finish tasks.
- Not infrastructure theater -- no scaffolding for its own sake, no plans instead of progress.
- Not self-graded -- every result is checked by a judge that Atrium doesn't control.
Real tasks, done end to end
If the goal is "deploy the fix," the fix is deployed -- not documented, not staged, not roadmapped.
The model thinks, code runs
An LLM plans and decides. What actually executes at runtime is ordinary, deterministic code -- no model calls hiding inside the loop.
How a run works
Goal in, verified result out
Every Atrium run follows the same shape, whether the task takes ten seconds or ten hours. Nothing ships until it has been checked by something other than the agent that built it.
You state the goal
Plain language, no ticket format required: "deploy the pricing update," "find out why signups dropped," "rebuild this page."
The orchestrator plans
A single orchestrator reads the goal and turns it into a concrete sequence of steps, deciding what needs to happen and in what order.
Work is delegated
Each step goes to the specialist built for it: a builder agent, a researcher agent, a verifier agent, a utility agent -- one job each, done well.
Workers do the real work
Code gets written and deployed. Browsers get driven. Tools get called. An actual artifact comes out the other end -- not a description of one.
An independent judge checks it
A separate verifier compares the live result against acceptance criteria that were written down before the run started. Atrium never grades its own homework.
What ships is the result itself
Not a plan, not a report about a result -- the finished, verified thing, already live. If a step fails, the run keeps its state and resumes.
Principles
The Seven Laws Atrium Doesn't Bend
These aren't aspirations. They are constraints enforced in how the system is built, not rules the model is merely asked to follow.
Finish, don't prepare
No infrastructure theater. Real tasks are done end to end -- the deliverable is the work, not a plan for the work.
Independent verification
Atrium never grades its own homework. An external judge checks the live result against acceptance criteria written before the run began.
No resets, only iteration
A failure doesn't erase progress. Every run leaves a resumable state; the next attempt picks up where it left off.
Orchestration over generalism
One orchestrator delegates to specialized worker agents -- builder, verifier, researcher, utility -- instead of one generalist doing everything badly.
LLM thinks, code runs
The model plans and decides. Deliverables execute as deterministic code -- no LLM calls left inside the runtime loop.
Gated, reversible-only autonomy
Irreversible or outward-facing actions -- deploy, publish, push -- require the owner's one-tap approval, enforced by hooks, not good intentions.
Ship the real thing, or nothing
No vaporware, no mockups presented as done. If it isn't finished and live, it isn't reported as finished.
Safety
Gated Actions, Enforced by Hooks
Atrium can do a great deal on its own. The things it can't do alone are the things you can't take back.
- Every gate holds:deploys, publishes, pushes, deletions, and payments pause for explicit, one-tap owner approval.
- The gate isn't a suggestion:it is enforced by hooks in the system itself, not by an instruction the model could talk its way around.
- Reversible work is free:drafting, building, and testing in a sandbox run without asking permission.
Deploy to production?
builder-agent wants to push 3 files to botatrium.com. This action is irreversible and outward-facing.
A run, transcribed
What "finished" actually looks like
This is a representative transcript of one Atrium run -- not a mockup, the actual shape of the log.
$ atrium run "deploy the pricing page update and confirm it's live"
> orchestrator: plan created -- 4 steps, 3 agents
> delegating to builder-agent...
> builder-agent: code written, local checks passing (9/9)
> gated action: deploy → awaiting owner approval
> owner: approved ✓
> builder-agent: deployed to production
> delegating to verifier-agent...
> verifier-agent: checking live URL against acceptance criteria...
> verifier-agent: PASS 13/13 -- run complete, result is live