Coding Agent Platform
“Restate now handles all durable orchestration at Replit, giving us the flexibility to rapidly expand what our agent platform can do.”
CloudBYOCOpen-source
The Durable Runtime for your Agents and Backends
Flexible building blocks that compose into agents, workflows, and microservices.
Low-latency durable execution, driven by a fast distributed log.
Durable Execution. Evolved.
Going beyond workflows: low latency, easy to integrate, ships as a single binary.
- Agents and logic often don't fit the workflow-activity shape.
- High overhead per durable step → remote workers poll for activities.
- Heavy to deploy and operate.
- COMPOSABLEAdd durability to any function, call or interaction.
- FASTDurable actions execute within your function, 10–100× faster.
- SINGLE BINARYScales out to highly-available clusters.
Trusted for mission-critical use cases
ERP Workflow Engine
All business-critical backend workflows are driven by Restate, by mapping their DSL onto Restate's primitives.
Fortune-100 US Bank
Financial transactions
Restate powers their treasury workflows with multi-regional strong consistency.
Built by the original creators of Apache Flink and engineers behind Meta’s planet-scale event infrastructure.
Run your own way
Durable building blocks that compose
rst.service({ name: "DeepResearch", handlers: { run: async (restate: Context, query: string) => { // Durable step const plan = await restate.run("plan", () => llm.plan(query)); // Parallel, long-running tasks, only the failed task retries const tasks = plan.map((task) => restate.serviceClient(researcher).run(task), ); const findings = await RestatePromise.all(tasks); // Durable step return await restate.run("write", () => llm.summarize(findings)); }, },});Observe and control your services
View execution journals and cancel, kill, restart, or pause any execution.
A purpose-built distributed runtime, engineered to be
Restate is not layered on top of a database. It is a purpose-built system, where all pieces are crafted together to provide fast durable actions, strong consistency, scalability, high-availability and resilience, resource efficiency, and a simple operational footprint.
P99 latency overhead under load per durable action
< 10 ms
Powering customers with
> 100k actions/s
Drop Restate into
the stack you already use.
Write plain code in the languages and frameworks you already use. Add durability in a few lines.
Agent integrations
Vercel AI SDK
OpenAI Agents SDK
Google ADK
Google GeminiRestate SDKs
Containers and serverless
Kubernetes
Google Cloud Run
Cloudflare
AWS Lambda
Powerful infrastructure
that feels simple.
“As we continuously evolve our agent architecture, we realized we needed a new durable execution runtime that was both fast and a pleasure for developers to work with. Restate fit that bill perfectly. It now handles all durable orchestration at Replit, giving us the flexibility to rapidly expand what our agent platform can do.”
Michele Catasta
President at Replit
“Restate is cloud native durable execution done right. The primitives are elegant and scaling is incredibly straightforward. It makes building resilient architectures too easy. Use it!”
Bradley Shawyer
Staff Engineer at Cinder
“Within a week, we were able to build a financial transactions workflow (and the confidence that it works) that had previously taken us months to build.”
James Corley
Engineer at Fortune-100 US Bank
“Restate took away a lot of the plumbing work, so most of our time is actually being spent on product work fleshing out UX and features for the end user, while Restate just works under the hood.”
Kyle Mckay
Engineer at Cinder
“Restate is one of the most impressive technologies that I have used in recent years. It is like Microsoft Orleans and Temporal had a baby.”
Ibrahim Koz
Engineer at Edge Delta
“Restate is one of the coolest pieces of software I have encountered in a while. Not often, a tiny well-crafted application comes along that forces you to fundamentally rethink software design.”
Kevin Webb
Urban Traction
“Restate is much better from an engineering perspective. It's more flexible than alternatives, and the self-hosting option was crucial for us.”
Alon Gubkin
Engineering Lead at Coralogix
“Nothing matched what Restate offers. It handles durability, retries, idempotency, ordering, workflows—everything you'd typically face in a distributed environment. The best part is that everything integrates seamlessly, just like regular code. No special setup required.”
Raghavendra Muppirisetty
Backend Lead at Dodo Payments
“Writing complex, highly dynamic tasks is effortless with Restate's SDKs. Restate's durable execution gives us a ton of peace of mind and troubleshooting is super easy thanks to great introspection tools.”
Sebastian Gepperth
Head of Product at Axite
“Moving to Restate has been a game-changer for Rhize. The fine balance of simple elegance and power is brilliant.”
Geoff Nunan
CTO at Rhize
“Being able to have durable execution off of serverless is... incredible.”
Nubunto
“Everyone at my company is absolutely shocked at how easy it was to get up and running with Restate. In a couple of hours, we successfully implemented Restate as the orchestrator of a job pipeline that was previously very error prone.”
Sebastian Hindhede
CTO Advisoa
“Restate's dev experience has no right looking and feeling this good. Putting every other tool in the space to shame in a big way.”
Christian
“With Restate I was able to build a working service in 4 hours with resiliency that alone would require triple amount of time.”
Kacpi
“We built a complex AI Agents game with Restate. And after you build a state machine with Restate, you cannot go back to DIY.”
Aris Kyriakos Koliopoulos
rated
“Restate basically powers our whole platform from candidate intake to transcription to the orchestration of every workflow that we have.”
Stephan Gilli
Co-founder at Deliveru
“We migrated our DSL implementation onto Restate as it was, and it just worked. The simplicity of mapping our workflow primitives onto Restate's building blocks is what made the migration possible without needing to redefine the primitives.”
Srujun Thanmay Gupta
Founding Engineer at DOSS
“We just exchanged all of our internal run functions with restate.run and it mostly just worked. And the UI is much nicer than looking at database columns all day.”
Andreas Thomas
CTO at Unkey
“We use Restate for durable execution across our agent / infra platform. Aside from rolling our own, it was the only tool that fulfilled our requirements. Genuinely been a pleasure to build on!”
Nick Raziborsky
CTO at Temper
FAQ
What is Restate?
Restate is a durable execution runtime for building resilient services, workflows, and AI agents. Your business logic stays in normal application code, running on the infrastructure you choose. Restate journals its progress, coordinates calls, and keeps state consistent so the application can recover from failures without losing completed work.
What does Restate provide beyond durable execution?
Durably executing one function is only part of making an application resilient. Restate applies the same guarantees to communication and state: service calls are delivered reliably, timers and signals survive restarts, and keyed state stays consistent with the code that changes it. The same guarantees also power Restate’s queues, flow control, and operational tooling. Together, these primitives can make an entire distributed application resilient.
Is Restate a workflow engine?
Restate includes durable workflows, but it is not limited to a workflow-and-activity model. Basic Services are ideal for independent durable functions, Virtual Objects model stateful entities with a single writer per key, and Workflows coordinate multi-step processes that run once per ID. These service types call one another directly, so teams can compose workflows with the rest of their backend instead of putting every problem inside a workflow.
What is durable execution?
Durable execution lets code continue through failures, restarts, and deployments. Restate records each durable step and its result in a journal. During recovery, completed steps are replayed from the journal and execution resumes at the first unfinished step, without repeating work that already succeeded.
Can I use Restate to build AI agents?
Yes. Restate can make one agent loop durable or provide the runtime beneath an entire agent platform. It durably executes model and tool calls, keeps sessions isolated and stateful, coordinates agents, waits for approvals without holding compute, and makes live executions observable and controllable. You can keep using your preferred LLM SDK or agent framework; Restate handles the distributed-systems work around it.
How does Restate control concurrency for AI agents and multi-tenant systems?
Restate routes invocations through durable virtual queues. You can scope concurrency limits to a tenant, team, user, workload, or downstream dependency, and combine them hierarchically—for example, a limit for an organization with smaller limits for each team and user. Work that cannot run yet remains durably queued. The runtime applies backpressure and shares capacity fairly.
Does Restate need a database?
The Restate Server runs as a single binary and does not require an external database, message broker, or cache. A single node stores its log and state on persistent disk. For high availability, the same self-contained binary can be deployed multiple times to scale out to a replicated cluster, with object storage for snapshots. Your application can still use Postgres or any other database when relational queries or existing data models call for one.
Why isn’t Restate built on top of Postgres or Kafka?
The requirements we had for Restate, were different enough to make a purpose-built solution the pragmatic choice. Building a durable execution runtime for interactive workflows places specific demands on the log: extremely low write-to-read latency, topology-aware replication, flexible storage, seamless reconfiguration, and one binary that scales from a laptop to multi-region production. Those requirements could not be met by building on Kafka, Postgres, or object storage. Kafka prioritizes throughput, Postgres provides the wrong abstraction and scaling model, and object stores add too much write latency.
Which programming languages does Restate support?
Restate provides SDKs for TypeScript, Python, Java, Kotlin, Go, Rust, and Ruby. Services written in different languages share the same protocol and can call one another, so teams can choose the right language for each part of a system.
Is Restate open source?
Yes. Restate itself has a BSL license and is available for self-hosting for production workloads. The SDKs have an MIT license.
How is Restate deployed?
Your application services remain ordinary processes and can run on servers, containers, Kubernetes, or serverless platforms. Run the Restate runtime yourself as a single node or replicated cluster, use fully managed Restate Cloud, or choose Restate BYOC for a managed deployment in your own cloud account. The code and programming model stay the same across those options.
How is Restate different from Temporal?
Both Restate and Temporal are highly resilient durable execution systems, running large-scale production clusters with high availability. Both let you pause work for a month and reliably resume it, even after failures or restarts. Temporal centers the application model on workflows and activities; Restate makes the wider system durable through composable services, workflows, keyed state, RPC, messaging, and queues. Restate also runs as a self-contained binary without an external database, while your services remain ordinary applications that can run on servers, containers, or serverless platforms.