Your agent died at step 47.
Resume it there — or fork it and try a different step 48.
Change the decision at the exact step, inherit the real accumulated state, and continue without re-running the first 47 steps or re-firing a tool the parent already ran. Actae is the framework-neutral execution layer under the loop you already own — LangGraph, OpenAI Agents, Claude, CrewAI, or custom code. Free and self-hosted in one binary, or managed Cloud.
Reproducible from committed reports: forking past the first five steps of a ten-step run saved 8,260 tokens (46.8%) in the deterministic demo; in the durability benchmark, naive retry re-fired 4 already-applied effects in a six-step run.
version 12 · committed atomically
result stored · sources accepted
writer · 2,840 draft chars
connection_lostInherited work restored. No steps rerun.
Each fork inherits the same boundary, then diverges.
Run the agent once.
Fork the decision. Compare the outcome.
A trace tells you what happened. Actae lets you change what happens next — from the exact saved boundary, with the inherited state and known tool results, and without re-firing a side effect the parent already performed. The loop is recover → fork → compare → promote. Why not Temporal, Inngest, or a LangGraph checkpointer? →
Fork the execution, not the trace
Fork from a saved step, change the next decision, and choose what happens to inherited side effects — replay, block, or run live. Immutable lineage, structural diff, and a promotion decision.
Coordinate retries that cannot double-execute work
Claim tool operations with durable idempotency keys and leases. Reuse a recorded result or fence a stale worker instead of sending, charging, or writing twice.
Crash without starting over
Resume from durable state and the exact event cursor your agent reached.
Give every worker the full story
Durable agent messages, fenced leases, causal history, and replay-to-live delivery keep multi-agent workflows coherent.
Your agent should not forget an hour of work because one worker died.
Processes restart. Networks time out. Tool results arrive ambiguously. A trace can explain the loss. Actae gives the application the durable state and execution history needed to continue.
recordtransitionreplayforkresumesubscribeThe rest of the runtime,
behind one API.
The whole system ships as one deployable: an ordered event log, atomic state, live WebSockets, coordination, lineage, and operational guardrails. Use the high-level SDKs or call the REST and WebSocket protocols directly.
Ordered events + atomic state
Record, query, and replay immutable events; commit an event and its cursor-aligned state snapshot in one PostgreSQL transaction.
Replay into live delivery
Catch up from each subscriber's cursor, cross a deterministic synchronization point, and continue over WebSocket without an event gap.
Durable coordination
Consumer groups, scheduled wake-ups, distributed execution groups, causal messages, fenced leases, and crash-safe acknowledgements.
Compare and promote experiments
Group forks, record outcomes, rank variants, inspect structural state and tool-result differences, and promote a winner.
Verifiable history
Per-channel hash chains, immutable fork receipts, decision trails, reproducibility grades, and provenance-aware retention.
Production guardrails
API-key and JWT auth, optional mTLS, rate limits, atomic usage quotas, metrics, health probes, configurable retention, and audited administration.
SDKs and framework adapters
Async-first Python, Go, and TypeScript clients plus integrations for LangGraph, LangChain, Claude, OpenAI Agents, CrewAI, Codex, and GitHub Copilot.
Every participant arrives fully caught up.
A new worker, dashboard, evaluator, or approval agent can replay durable history from any cursor and move into live delivery without a race or a hand-built handoff.
1 await actae.record(channel, event) 2 await actae.transition(event, state) 3 4 // recover history, then stay live 5 for await (event of actae.stream({ cursor }))
Bring the framework.
Keep control of execution.
Actae does not choose prompts, models, or tools. It makes the facts of execution durable underneath the stack you already use.
One deployable system
Ordered event log, versioned state, live WebSockets, consumer coordination, and execution lineage behind one endpoint.
Choose the boundary
Use a dedicated managed Cloud runtime for zero operations or self-host Actae when execution data must remain in your infrastructure.
Evidence, not screenshots
Fork receipts and causal histories connect the outcome to the exact boundary, state, tools, and decisions that produced it.
Your application stays in control.
Actae runs beside your agent as the durable event, state, coordination, and lineage layer.
- Persist ordered steps and versioned state
- Fence and replay logical tool operations
- Recover, fork, compare, and stream execution
- ×Choose prompts or models
- ×Plan tasks for your agent
- ×Own or execute your application loop
One execution model. Your deployment boundary.
Start with a dedicated managed Cloud endpoint, or run the same production Actae runtime in your infrastructure when data residency or network control requires it. Cloud onboarding is assisted and no public availability SLA is currently offered.
Compare deployment options# download the free community build $ chmod +x ./actae # start API + dashboard + managed PostgreSQL (banner prints URL + API key) $ ./actae # install an SDK and record your first event $ pip install actae-client
Start free. Add Cloud when you want it operated.
Run the self-hosted community build yourself at no cost — no account or card. Every Cloud plan starts with a 30-day Polar-managed trial; a card is required and you pay nothing if you cancel before day 30. Tiers differ by monthly event and data-written allowances, retained-data cap, retention window, team members, support level, and rate limits; every Cloud plan includes the managed runtime, the portal, API keys, forks/recovery, effect ledger, encrypted backups, and usage warnings.
forever
- Self-contained binary + embedded PostgreSQL
- Single node — no account or card
- Forks, effect ledger, crash recovery
- Community support
per month
- 50k events / month
- 1 GB data written / month
- 2 GB retained data
- 7-day retention
- Isolated hosted installation
- Community support
per month
- 1M events / month
- 10 GB data written / month
- 20 GB retained data
- 30-day retention
- Unlimited team members
- Email support
per month
- 5M events / month
- 50 GB data written / month
- 100 GB retained data
- 90-day retention
- Higher rate limits
- Priority support
Two limits keep your runtime predictable.
The monthly flow meter: events, saved state, and tool results accepted by Actae during the billing period.
The current logical payload Actae stores, including state versions and fork copies.
The portal flags 80%, 90%, and 100% usage. At the cap, new writes are rejected atomically before they can change state; monthly meters reset with the billing month, while retained capacity returns through retention/deletion or a plan upgrade. Store large artifacts in object storage and keep only a reference in Actae.
Prices exclude applicable taxes. Polar is the merchant of record. No annual plan is currently offered.
Operating posture, stated plainly.
Actae Cloud has isolated tenant runtimes, PostgreSQL control-plane recovery tooling, usage guardrails, component health reporting, and operational alerts. It does not yet claim a public SLA.
Live service healthCustomer-visible component status refreshes every 30 seconds.View current status
SLA gates remain explicitMulti-node recovery, PostgreSQL HA, an external security review, formal on-call ownership, and measured margins must be evidenced before a public SLA is offered.Review security posture
Make one agent run survive a crash — then fork it.
Download the free self-hosted build and fork a run on your own machine, or bring one workflow that already runs for 10+ minutes and we will provision a dedicated Cloud endpoint and help you prove recovery and forking against your own agent.