Agents that pause,
not burn.
An agent that sits idle 99% of the time still costs you 100% of a server. Agent Substrate suspends a run to durable state the moment it starts waiting — on a person, a schedule, a webhook — holding no worker, then resumes on exactly the step it left.
- fetch_invoices12 documents · 2.4s
- extract_fields12/12 parsed · 8.1s
- validate_totals1 mismatch flagged · 0.3s
- send_invoice_emailawaiting human approval
- archive_batchqueued behind approval
Code it, draw it, or ship it — same durability.
Engine
Import it directly
A Python async framework underneath everything else. Write the agent in code, and the suspend/resume behavior every other surface gets for free is the same runtime call.
from substrate.agents.core import ReActAgent
from substrate.capabilities.tools import AskHumanTool
agent = ReActAgent(
tools=[AskHumanTool(), send_invoice_email],
model="gpt-5.4",
)
async def run(ctx, inbox):
await agent.run(ctx, inbox) # suspends + resumes automaticallyBuilder
Compose it visually
Drag agents, tools, guardrails, and approval gates onto a canvas. The graph the builder produces is executed by the same durable runtime — not exported to a different format first.
Chat
Ship it as a surface
Deploy the same graph as a project-scoped chat interface with streaming, memory, and file handling. A run suspended waiting on approval shows up here as a card, not a dead conversation.
Durability is not a feature we bolted on
Built for runs that outlive the request.
Waiting is a state, not a bill
The moment a run blocks — on a person, a cron, an inbound webhook — its state is written to Postgres and the worker is released. Nothing spins. Nothing polls a database in a hot loop waiting for an answer that lands tomorrow morning.
Every step survives the pause
Runs are an append-only event log, not an in-memory call stack. Which tools ran, what came back, which guardrail fired, why it stopped — all still there after the suspension, after a deploy, after a crash.
Human approval, built in
Risky tool calls stop and ask. The reviewer gets the call, its arguments, and the risk classification — and can take as long as they need, because a run waiting on them costs the same as a run that finished.
Send 12 invoice emails to external recipients?
- tool
- send_invoice_email
- risk
- external side effect
- waiting
- 2h 14m · 0 workers held
One graph, drawn and run
Compose the pipeline visually from typed nodes — agents, tools, routers, guardrails, approval gates, loops. The artifact the builder produces is the artifact the durable runtime executes. No export step, no second source of truth.
Runs measured in seconds days
Long-horizon work — approvals that land tomorrow, schedules that fire next week — stops being an infrastructure problem you route around.
State lives in Postgres, not in a parked process.
Minutes or months — resumption is an event, not a timeout.
Agents, tools, routers, guardrails, approvals, loops.
Web, code interpreter, documents, email, task boards.
Add it to a project, or run the whole platform
Use it as a library
Published on PyPI. Import the agent loop directly into your own code — no server to stand up first.
$uv add agent-substrate --prerelease=allowfrom substrate import ReActAgent, RuntimeRun the full platform
Same package — add it, then run its FastAPI server, durable runtime, and observability stack directly. Needs Postgres and Redis; see the full setup guide for env vars and infra.
$uv add agent-substrate --prerelease=allow && uv run start