Side by side. What each category gives you out of the box.
The other columns describe each category in general terms. Individual products vary, and many teams use more than one.
| Capability | Alchemy | Observability | Orchestration frameworks | Hosted runtimes |
|---|---|---|---|---|
| Watching the work | A live control center: every agent, task, step, cost and file, with replay, fork and compare | Traces and dashboards of what was sent | Whatever you build | The vendor’s console |
| Managing the team | Roles, reach and hand-offs in one manifest; edit agents with AI, versions kept, skills approved | Not in scope | Wired in your code | Per-agent settings |
| Spend ceilings | Per task, plus daily and monthly limits per project and account, enforced before each step | Reports spend after the fact | Built by you | Budgets on the vendor's platform |
| Approval of actions you mark | Held for an administrator; no agent can approve | Not in scope | Middleware you add per tool | Per-tool permission settings |
| Definition of done | Every deliverable opened by an independent agent before a run can finish | Scores traces after the run | Whatever your code checks | Varies by product |
| What the agent saw at each step | Kept for every step, exactly | Traces sent by your instrumentation | Checkpoints of workflow state | Session logs in the vendor's store |
| Outside actions after a crash | Reconciled, never repeated | Not in scope | Your code's responsibility | Varies by product |
| Who may touch what | Per-agent reach and delegation in one manifest | Not in scope | Wired in your code | Per-agent tools and policies |
| The record | Encrypted, hash-chained, exportable and independently verifiable | Searchable traces | The state store you configure | Logs held by the vendor |
| Where it runs | Your infrastructure | Vendor cloud or self-hosted | Wherever you deploy it | The vendor's infrastructure |
| Pricing | Licence per organization; nothing metered | Usually metered by trace, span or seat | Open-source libraries; hosted tiers metered | Metered by usage and runtime |
A trace tells you what happened. Alchemy shows you, and decides what may happen next.
Tools such as LangSmith, Langfuse and Datadog capture prompts, outputs and costs, and they do it well. But a trace is assembled after the call, from what your code chose to send, and it watches one agent at a time.
Alchemy is observability built for a team of agents: who is working, what is waiting on whom, where the money went, and which file is the deliverable, live or replayed moment by moment. Because it keeps its own record as the work happens, it can also act on what it sees: spend is checked before the next step, marked actions wait for a person, and the record stays encrypted on your disk, ready to export and verify. Keep your dashboards; Alchemy adds the team view and the controls they were never built to give.
Frameworks give you building blocks. Governance is still yours to build.
LangGraph, CrewAI and similar frameworks are flexible ways to wire agents together. Approvals, spend limits, access boundaries and an audit trail are left to your code, one tool and one project at a time.
In Alchemy they are declared once, in the manifest. It names every agent, what each may touch and to whom it may hand work, which actions wait for an administrator, and what counts as done. The engine enforces all of it at every step, and the manifest is one file your security team can review.
Durable engines make steps reliable. They do not know what your agents are for.
Temporal, Inngest and similar engines survive crashes and retry steps well. They bring no organization of agents, no approvals declared per action, no spend ceilings on model use and no definition of done; you build those on top.
Alchemy is that layer, built for agents. A crash costs only the steps in flight, and an outside action is never repeated after one: it is reconciled against what actually happened, and anything uncertain goes to a person.
Hosted runtimes run your agents for you. Alchemy keeps them with you.
Model and cloud providers now offer hosted agent runtimes with budgets, tool permissions and evaluation. They are convenient, and the agent loop and its record live on the vendor's infrastructure.
Alchemy runs the loop, the approvals and the record on infrastructure you control, on your own Anthropic account. Nothing is sent to Agiliti, model spend is never marked up, and the evidence of every run stays on your disk, in a form an auditor can verify independently.
Control planes govern the boundary. Alchemy governs the work inside the run.
Enterprise agent registries, AI gateways and policy layers inventory agents, route requests and block calls a policy forbids. From the edge, they see a request.
Alchemy sees the run: which agent asked, what it had been handed, whether the action needed approval, and whether the deliverable was checked before the work was called done. The two layers are complementary. A gateway decides which requests may leave your network; Alchemy decides which work may proceed, who signs off on it, and what evidence it leaves behind.
When Alchemy fits. Agent work that has to answer to someone.
You cannot see what your agents are doing
Agents run in many places, and nobody can say which are working, what they touched or what they cost. Alchemy gives every team of agents one place to be watched and managed.
Agents act beyond your walls
They push code, open pull requests, file, publish or pay for services, and those actions must wait for a named person.
Spend has to be predictable
Finance wants ceilings per task, project and month, and no metered invoice from the platform.
Evidence has to hold up
Audit and compliance need a record the model did not write, kept on your infrastructure and verifiable without the vendor.
Data has to stay in-house
Alchemy runs on your own Windows, Linux or macOS infrastructure or in Docker, model use is billed to your own Anthropic account, and nothing is sent to Agiliti.
One team of agents, not a pile of scripts
You want agents that plan, delegate and deliver as one organization, with independent tasks running side by side within limits you set.
Done has to mean done
Every deliverable is opened by an independent agent against a written definition before a run can finish.
Questions buyers ask when comparing. Answered plainly.
How is Alchemy different from LangGraph or CrewAI?
LangGraph and CrewAI are frameworks for writing agent logic in code; governance controls such as approvals, budgets and audit are largely yours to assemble. Alchemy is a governed runtime: you describe the organization in a manifest, and it enforces approvals, spend ceilings, definition-of-done checks and a tamper-evident record while the work runs, on your infrastructure.
How does Alchemy compare with hosted agent runtimes?
Hosted runtimes run your agents on the vendor’s infrastructure and typically meter usage. Alchemy runs as one process on infrastructure you control, meters nothing and uses your own Anthropic account, so records, deliverables and spend stay with you. The trade-off is that you operate it yourself instead of renting a managed service.
Is Alchemy an observability tool?
It includes observability built for teams of agents: a live control center, replay of any run, comparison of runs and an AI audit of what every agent did. It also does what an observability tool cannot: it checks ceilings before each step, holds marked actions for a person and will not finish a run until an independent agent has checked the deliverables. Many teams keep their tracing tools alongside it.
Can I use Alchemy with models other than Claude?
No. Alchemy runs Claude models and is built on Anthropic’s Claude Agent SDK. If you need several model providers in one system, a multi-provider framework may suit you better. If Claude fits your work, Alchemy gives you a governed runtime with approvals, spend ceilings, verification and a complete record without building those controls yourself.
When is a framework a better choice than Alchemy?
Choose a framework if you are embedding a single agent in your own product, need models from several providers, or want to hand-code agent control flow. Choose Alchemy when a team of agents does consequential work and you need approvals, spend ceilings, independent verification and an audit-ready record running on your infrastructure from day one.
Governed agent work, on your infrastructure. Nothing metered.
Start with an evaluation, or build your first organization of agents with us in an eight-week design partnership.