Five things happen in every step. Always in this order.
The step is the unit of work, and every step leaves an entry in the run's record.
1. What the agent is given is kept
Alchemy keeps exactly what the agent is given for this step: its instructions, the task, the files handed to it, its tools and permissions, and the versions of any memory or knowledge it can read. Later you can see precisely what the agent was working from, not just what it said, and a retried step starts from the same place.
2. Ceilings are checked
Alchemy checks the run's spend ceiling and any daily or monthly limits for the project and account, allowing for steps already in flight. When a ceiling is reached, no new step starts until an administrator decides.
3. The agent works
Claude runs one turn in the agent's own workspace. Tool calls are checked against the agent's grants; reads and writes outside the workspace are refused. Text from outside is marked as observed content, not instruction.
4. Outside actions are logged, and never happen twice
When an agent asks to push code, post a comment or make a paid call, Alchemy logs the request and then the result. If anything is interrupted in between, Alchemy checks what actually happened instead of trying again, so nothing is done twice. Actions that cannot be undone, or that need approval, run as their own step, never inside the agent's work.
5. The outcome is recorded
The turn ends in one of four outcomes, checked against the manifest. Delegating outside permitted edges, requesting an action the agent does not hold, or citing a deliverable it never received is refused and logged. Spend, tokens and time are recorded with the outcome.
Agents never call each other. Every turn ends in one of four ways.
Deliver
The task is done. The agent hands over its deliverables and a short handoff note. For the lead, the definition of done decides whether the run may finish.
Delegate
The agent creates tasks for named teammates within its permitted edges. Independent tasks run side by side, and the parent waits as a recorded entry, not an open session.
Need a person
The agent asks a question with options. That task waits for the person who started the run or an administrator, while the rest of the run keeps working. The record shows who answered.
Fail
The task cannot be done, and the agent says why, with evidence. A task that reaches no outcome within its turn limit is failed; a person can reopen the run.
Done is written down. An independent agent checks it.
Before a run can finish, an agent that did none of the work opens every deliverable against the project's written definition of done. The check is on by default.
- 01
The definition comes first
Each project declares what it must deliver (the files, their types and minimum sizes) and which agent checks them. The definition is pinned when the run starts, and the lead knows its terms before work begins.
- 02
Alchemy checks the contract
When the lead reports done, a missing, empty, undersized or mistyped deliverable is sent back for correction.
- 03
An independent agent checks the work
The checker receives the deliverables, the goal and the lead's handoff, but none of the lead's reasoning. It cannot be the lead or have written anything it checks, and it must open every file, including every image.
- 04
A person settles the last word
The lead fixes what the checker finds and submits again. If the work still falls short after two rounds, a person decides: accept it as it stands, recorded as a waived check, or say what still has to change.
Properties of the runtime. Not instructions in a prompt.
These hold on every run, whatever the manifest, the model or the task.
Exactly what each agent saw
For every step, Alchemy keeps exactly what the agent was given, so any decision can be traced back to the information behind it.
At most once, then reconciled
A declared outside action is never repeated after a crash. One with a recorded result is finished from its receipt; one whose result is uncertain goes to an administrator, never back out automatically.
Only a person approves
An approver can be a person or nobody. A manifest that names an agent as approver is refused when it loads. Approvals are decided by an administrator, in the control center or from an alert.
A pinned manifest
The manifest is fingerprinted into the run's first record. Moving a running project onto an edited manifest is an explicit, recorded change.
Allow-listed reach
Each agent reaches only the files, tools, connections and actions its manifest entry grants. Tool servers are held to an approved tool surface, checked when each step starts.
A tamper-evident record
The run's record is append-only, hash-chained and encrypted on your disk. Every view in the control center is rebuilt from it, and an exported copy can be verified independently.
Every declared action has an approval, a reservation and a receipt.
Anything that leaves the machine through Alchemy, such as a branch push, a pull request, a ticket update or a paid generation, is declared in the manifest as an action. Agents request declared actions; Alchemy runs them under the rules you set.
One action passes. One waits for a person. The record keeps both.
Model spend is governed alongside. Every run carries a spend ceiling you set, checked before each step. Optional daily and monthly limits apply per project and across the account, and hold even when many runs start at once. At a ceiling, an administrator continues with a new figure or stops the run.
Approval
a person or nobodyMark an action for approval and it waits for an administrator's decision in the control center or from a Slack, Teams or webhook alert, while the rest of the run keeps working.
Executor
any agent, or one named agentName the one agent allowed to run an action, and it runs as its own recorded step, separate from the agent that asked for it.
Reversibility
yes or noIrreversible actions never run inside an agent's turn. If the outcome of one is uncertain, it goes to an administrator rather than being retried.
Reservation
per paid callActions billed per call reserve against the run's paid-call ceiling before they go out. A call that would exceed the ceiling is not sent.
Receipt
every callEach action is recorded as attempted before dispatch and as done, with its result, when it returns. After a crash, Alchemy reconciles from that receipt instead of calling again.
A brand crisis, worked end to end. With a CEO decision and a signed-off release.
One manifest describes the whole team: 23 agents, what each may read, which actions wait for a person, and what counts as done. What the crisis is lives in the knowledge bases, so the same team can work any scenario you load.
Staffing the room
The commander reads the exercise setup and hands the whole job out in one delegation: who listens, who advises, who writes.
Listening
Monitors watch every beat of the feed at once and the lead writes one listening report. A web analyst finds earlier crises of the same kind, cited.
The narrative map
Every narrative with its volume, its speed, whether it is true and how dangerous it is, checked against the company's own records.
Every audience
Each stakeholder group is played from its own card: how it reads the situation now, and how it would read each strategy. They never see the company’s records.
Advice from every seat
Communications, legal, security, people, partners, trade, investors and government affairs each give their advice, from their own reading list.
Three futures, one scorecard
Each strategy is played forward against its own future, and one scorecard compares them. Only game control may see the futures.
The CEO's decision
The chief of staff resolves the functions' conflicts into a decision memo and puts the choice to the CEO as a card. The run waits, at no cost, until a person answers.
Write, attack, review
One fact base and message matrix; every document drafted for its audience, attacked by a hostile reader, reviewed against counsel’s rules and revised once.
The pack
The response suite and decision memo in Word, a board deck in PowerPoint and a situation board, each with its PDF, checked before anyone is asked to approve.
Release and completion check
The release waits for a person’s approval. Then an agent that wrote none of it confirms the pack is whole before the run can finish.
A crash costs only the steps in flight. The rest of the run is already on disk.
People decide how a run ends. Accept as done requires a note and is refused while any action is uncertain. Stop closes open approvals as abandoned; no ending approves anything. Reopen continues a finished run with a recorded reason.
The process stops
restartOn restart, Alchemy replays the record. An outcome already recorded is finished without another model call, and each step that was in flight runs again from its saved context in a fresh workspace.
An action was in flight
reconciliationActions with a receipt are completed from it. An action whose result is uncertain is never sent again automatically; a paid one keeps its reservation, and an administrator decides whether it happened.
The provider pushes back
errors and capacityTransient errors are retried with back-off. When usage capacity runs out, the step is parked and resumes as the same turn once capacity returns, with no work lost.
A decision is pending
waitingA task waiting for a person holds no live process, so it can wait over a weekend at no cost while other work continues.
Common questions. Short answers.
What goes in the manifest?
The manifest describes your organization of agents in one place: its agents and lead, what each agent may touch, which actions need a person’s approval, the spend ceilings that apply and the written definition of done. Alchemy reads the manifest and enforces it while the work runs, so the rules you review are the rules that run.
What happens when an agent reaches an action that needs approval?
That action waits, and the request appears in the control center, with an alert to Slack, Teams or a webhook if you use them. An administrator reviews what the agent intends to do and approves or declines it. Other work carries on meanwhile, and the decision is written to the record alongside the action itself.
What happens if the process crashes mid-run?
Alchemy picks up from its record. Governed actions on outside systems, such as a push, a pull request or a ticket comment, are logged when requested and when completed, so after a restart Alchemy knows which ones already happened and never repeats them. If it cannot tell whether an action landed, it asks a person instead of guessing.
How do I show an auditor what the agents did?
Export the record. It holds what every agent was given, did and changed, together with every approval and the definition-of-done check. It is encrypted and hash-chained, so alterations show when it is verified, and it can be checked independently of Agiliti. Reviewers get direct evidence of human oversight instead of a summary written afterwards.
What do I need to run Alchemy?
A Windows, Linux or macOS machine you control with Node.js 22, or Docker, and your own Anthropic account: we recommend an API key, and a Claude subscription also works. Alchemy runs as a single process, so there is no cluster to operate. Your manifests, records and deliverables stay on that machine, under your existing security controls and backup routines.
See it run on your own work.
Evaluation access comes under a short written agreement. A design partnership puts Alchemy to work on one of your processes for eight weeks.