One manifest. Every agent, rule and deliverable.
Describe an organization of agents the way you would describe a team: who does what, who may hand work to whom, and which actions need a person.
Each project is one manifest. It names a lead and its agents, gives each its instructions and the exact tools, actions, files and knowledge it may reach, and defines the finished deliverable. The runtime refuses any hand-off that crosses the lines you drew, and every run is pinned to the manifest version it started on.
Approval rules live in the same place. Mark the actions that need a person, such as pushing a branch, opening a pull request, commenting on a Jira issue, publishing a Confluence page, filing or a paid call. That task waits for an administrator's decision while other work carries on; no agent can approve. Agents reach the outside world only through the actions and tool servers you grant.
Start from the setup wizard, one of 296 role templates or one of twelve ready projects. Edit any agent in plain words with AI, and every earlier version stays one click away.
Plan, delegate, deliver. In parallel where the work allows.
Hand the project a piece of work, or talk to one agent directly. The lead breaks it into tasks, and independent tasks run side by side within the limits you set.
Gates are precise. An action marked for approval holds only the task that asked for it, so the rest of the run keeps moving. A spend ceiling pauses the whole run until you set the next figure. Either way, the control center shows it and your alerts reach you wherever you are.
Runs survive crashes. The run resumes from its last recorded step, without repeating model calls whose results were already decided. Outside actions are never repeated blindly: Alchemy reconciles each against its receipt, re-sends a web API call only under the same idempotency key, and otherwise asks a person first.
Done is written down. And checked independently.
Each project states what its deliverable must be: the files, their types and which one a reviewer should open first. The lead sees those terms before any work starts.
When the lead reports the work complete, an agent that did none of it checks it against that definition. The checker receives the goal, the lead's summary and the files, not the lead's reasoning, and must open every deliverable, images included.
If the check fails twice, a person decides: accept the result or say what still needs to change. The check is on by default for every run.
Every finished task opens on its deliverable, with who checked it and what they opened.
Budgets you set in advance. Enforced before every step.
Before you start, a project previews the approvals the work is likely to reach and a likely cost, based on its past completed runs.
Run ceiling
Every run has a dollar ceiling, checked before each step and each billed model turn. When it is reached, the run pauses for your next figure.
Paid-call ceiling
Each call to a paid service is reserved against its own ceiling before it is sent.
Daily and monthly limits
Optional limits for each project and the whole account. Every way of starting or continuing work is checked against them.
Your key, your bill
Model use is billed to your own Anthropic account, directly and never marked up. We recommend an API key; a Claude subscription also works. Nothing is metered by Agiliti.
Connect your systems. Govern every action.
Bind outside systems as declared actions. Each can require approval, is reserved against a ceiling when it costs money, returns a receipt to the record, and is checked against the provider after a crash, never repeated blindly.
Each tool server's tool surface is pinned when first seen; if it changes, the server is held until an administrator approves. A person starts every run.
| Capability | What agents can do | How it is governed |
|---|---|---|
| GitHub | Push a branch, open a pull request and comment on it; read issues and pull requests through the GitHub tool server | Declared actions; mark each for approval and name the one agent that may run it |
| Jira | Search and read issues; comment, transition, create and update them | Each write is its own declared action with its own approval rule, found again after a crash |
| Confluence | Read pages; create and update pages | Page writes as declared actions, held for approval where you mark them |
| Web research | Search the web and read pages | Granted per agent, limited to the domains you allow, every access logged before it leaves |
| Tool servers (MCP) | Use the tools of any MCP server you grant | Tool surface pinned; any change held for an administrator |
| HTTP APIs | Call any web API bound as a declared action | Approval rules, receipts and idempotent retries |
| Documents | Write Word, PowerPoint, PDF and web pages in your brand or a client template | Rendered and checked by the platform, kept in the record |
| Media and voice | Generate images, video, voice and music | Paid actions, reserved against the paid-call ceiling |
A complete trail of every run. Sealed on your disk.
For every step, Alchemy keeps what the agent was given, what it did and what it changed, including every action that reached your systems. The trail is not a log added afterwards: it is the run itself, so an interrupted run picks up exactly where it stopped.
Each run is stored on your own disk, encrypted with AES-256-GCM under a key kept apart from the data, and hash-chained so any edit shows. An export carries digests an auditor can verify independently, without Agiliti and without your key.
Step through a run event by event, fork it from an earlier step, or compare two runs. A deleted run leaves a tombstone of what it did outside your infrastructure and who approved it.
Nothing is sent to Agiliti. Everything that can leave your infrastructure is documented on Trust.
What your agents know, and how they get better. Under your control.
Knowledge bases
Give a project your standards, records and playbooks, including PDF, Word, Excel and PowerPoint. Each step searches a pinned version, and you decide which agents may read which base.
Files with the task
Attach the documents a task needs when you start it. They are read once, kept on your machine, checked for credentials and cleared on a schedule you set.
Governed memory
Let agents learn across runs, including what a checker rejected. Every note records its source, notes from outside content are held for review, and any note can be revoked. Off until you turn it on.
Skills, approved before use
Add skills from the library or import them from GitHub. Each is read and judged before an administrator approves it, and every version an agent runs is on record.
Evaluations before change
Before changing a model, an instruction or an agent, rerun past checked work under the new version and see what held and what regressed. An AI audit can read every project nightly.
One place to manage, watch and decide.
Watch the team at work, answer what waits for you, and open the deliverable when it is done.
Approvals. Every waiting action lands in one Decisions inbox. An administrator or a named approver decides in the control center or from an alert, and every decision is recorded.
Alerts. Waiting decisions reach you in Slack, Microsoft Teams, by webhook or as a desktop notification, with reminders while they wait.
Replay and compare. Scrub any finished run moment by moment, fork it from a decision to try another answer, and compare two runs side by side.
Reporting. Spend by agent and by model, decisions requested, and review time per accepted deliverable.
Team
Who is on the team, what each agent may touch and what it is doing now.
Work
Every task in motion, waiting on you or finished this week.
Floor
An office of glass team rooms, live or replayed, desk by desk.
Score
Every step, who took it and what it cost, one lane per agent.
Board
Every file the team made, what it came from, and which one is the deliverable.
Questions about the platform. Answered plainly.
What does a governed AI agent runtime do?
A governed runtime executes AI agents while enforcing your organization’s rules at every step. In Alchemy that means scoped permissions for each agent, human approval of the actions you mark, spend ceilings checked before work continues, an independent check against a definition of done, and a complete, tamper-evident record of what every agent was given, did and changed.
How do I see what my agents are doing?
Open the Control Center. Team shows every agent and its reach, Work shows every task, the Floor shows where the work is happening, the Score shows each step and its cost, and the Board shows every file. Any finished run can be replayed moment by moment, forked from a decision or compared with another run.
How do spend ceilings work?
You set a ceiling for each task, plus optional daily and monthly limits for each project and for the whole account. Alchemy checks spend against those limits before each step, and when a limit is reached the work pauses and an administrator decides what happens next. Model use bills to your own Anthropic account, so the spend you see is your own.
What does the audit record contain?
What every agent was given, what it did and what it changed, along with every approval, refusal and spend decision. The record is encrypted and hash-chained, so altering a past entry shows when the chain is checked, and it can be exported and verified independently of Agiliti. Actions on outside systems are logged and never repeated after a crash.
How does Alchemy verify that work is actually done?
Every organization has a written definition of done. Before a run can finish, an agent that did none of the work opens each deliverable and checks it against that definition. If the check fails, the work goes back for another round, and a person decides if it fails twice. Done means checked, not merely claimed by the agent that did it.
Which integrations does Alchemy support?
GitHub for branches, pull requests and comments; Jira and Confluence; web search and fetch; MCP tool servers; HTTP APIs; media generation and voice. Actions on these systems are declared in the manifest, so it decides which agents may use them and whether a person must approve first. Alerts reach Slack, Microsoft Teams or any webhook.
What does the control center show?
The control center shows your organization of agents at work: who is doing what, which actions are waiting for approval, how spend compares with its ceilings and which deliverables are finished. It is where administrators approve or decline marked actions, and alerts to Slack, Teams or webhooks mean decisions never depend on someone watching a screen.
Run it on your own infrastructure.
Evaluation access is a private source checkout under a short written agreement. Alchemy runs as one self-hosted process on Windows, Linux or macOS with Node.js 22, or in Docker, and a built-in check confirms which model credential a run will bill before any real work starts.