Source-available · Self-host free · Servers + Mobile · Rust · PostgreSQL
Durable workflows that run on servers and phones — and survive crashes.
Define multi-step sequences as JSON — email campaigns, billing retries, onboarding drips, mobile field workflows, or AI agents that call tools and wait for human review. Orch8 handles scheduling, retries, rate limits, and crash recovery — on your servers or offline on mobile devices.
curl -fsSL https://orch8.io/start.sh | shInstalls, starts the engine, deploys a sequence, and runs it. Zero dependencies beyond curl and jq.
{
"id": "welcome_drip",
"blocks": [
{ "type": "step", "handler": "send_email" },
{ "type": "step", "delay": "3d" },
{ "type": "router", "branches": [
{ "if": "opened", "then": "followup_a" },
{ "else": "followup_b" }
]},
{ "type": "loop", "while": "pending_review",
"block": "human_review" }
]
}The problem
Every team builds this from scratch. Twice.
You need to send sequences of tasks over time — emails, notifications, follow-ups. There is no right tool for it, so you assemble one.
cron + Redis breaks under load
You start with a cron job and a queue. It works until you have 100k users, a deploy in the middle of a campaign, or a rate limit violation that burns your sender score.
Job queues handle jobs, not sequences
Bull, BullMQ, and SQS process one task at a time. Multi-step logic — wait 3 days, check if opened, branch — requires custom code stitching jobs together.
No branching mid-sequence
"If they opened email 2, send follow-up A; otherwise, send B in 48h" — that's a state machine you're now maintaining.
Rate limits get violated
Traffic spikes burn your sender reputation. Retry storms make it worse. Most queues have no concept of per-resource rate limits that defer instead of drop.
Tasks vanish on restarts
In-flight jobs at deploy time evaporate unless you built a recovery mechanism. Most teams haven't. They find out after a complaint from a customer.
3–6 months of eng time — gone
Your team built scheduling infrastructure instead of the product features customers pay for. And the infrastructure still breaks.
The solution
Define the sequence. We handle the rest.
Describe your sequence in JSON — steps, delays, conditions, retries. Orch8 schedules, executes, recovers from crashes, and enforces rate limits — on servers or on mobile devices. No infrastructure code. No state machines.
Time-aware scheduling
Steps can delay for hours, days, or weeks — with timezone support, jitter, and business-days-only options built in.
- — Delays from milliseconds to months per step
- — Timezone-aware scheduling with DST handling
- — Business-days-only send windows
- — Router blocks for conditional branching
- — Cron-triggered sequences with IANA timezone support
- — A/B split routing — deterministic, survives restarts
Resilience & control
Every step either completes, retries with backoff, or surfaces to your dead letter queue. Nothing silently disappears.
- — Per-resource rate limiting — overages deferred, never dropped
- — Automatic retry with exponential backoff and jitter
- — Output memoization — no duplicate sends on retry
- — Crash recovery — stale instances auto-reset on restart
- — Signals: pause, resume, cancel mid-execution
- — Idempotency keys prevent duplicate instance creation
Snapshot state, not event logs
Executions resume from the last saved checkpoint instantly — no history replay, no determinism constraints. Write normal handlers. Drop them in any language via the pull-based REST worker API.
Why not use what exists
The durable runtime for workflows and AI agents.
Job queues handle jobs. Python frameworks run agents that restart on crash. Orch8 runs both — durable sequences that schedule, and AI agents that call LLMs, dispatch tools, and resume from the last step after a crash.
cron + Redis
No state, no retry, no branching. Works until a deploy wipes your queue or a rate limit fires and everything floods at once.
Bull / BullMQ
Excellent job queue — but a job queue, not an orchestrator. Multi-step sequences require custom code that stitches jobs together.
LangGraph / CrewAI
Python frameworks for AI agent graphs. Agents restart from scratch on crash — no durability. No rate limiting on LLM calls.
Temporal
Powerful but heavyweight: code-as-workflow with determinism constraints, a separate cluster, and a steep learning curve.
Orch8
Task orchestration + AI agent runtime that runs on your servers and on mobile devices. Define workflows as JSON — email campaigns, onboarding sequences, field operations, or AI agents that call LLMs and wait for human review. Offline-first mobile execution with server-side visibility. Workers in any language via REST. SDKs for Node.js, Python, Go, and mobile (iOS/Android via Rust + UniFFI). No cluster, no determinism constraints, no platform lock-in.
Features
What you get out of the box
Crash-proof by design
Snapshot-based persistence — not event sourcing. Instances stuck in Running for >5 minutes are automatically reset. Debug mode with step-through breakpoints.
Output memoization
Step outputs are persisted after execution. Re-execution on retry returns the cached result. No duplicate emails, no duplicate charges.
Built-in concurrency control
Concurrency keys limit parallel runs per resource. Rate limits defer overages — never drop, never fail. Circuit breaker per handler.
A/B split primitive
Route N% of instances to variant A, M% to variant B via deterministic hash-based selection. Built for subject line testing, send time experiments.
SLA timers + session management
Per-step deadlines with configurable escalation handlers on breach. Group related instances into sessions — pause, cancel, or query by session.
Signals — control mid-execution
Send pause, resume, cancel, update_context, or custom signals to running instances. Workflow interceptors fire before/after steps, on signal, on complete, on failure.
Hot migration + dynamic injection
Deploy a new sequence definition without stopping running instances. Inject additional steps into a running instance at runtime — built for AI agent workflows.
AI agent runtime built in
llm_call handler supports 9+ LLM providers. tool_call dispatches to any registered handler. human_review pauses an agent for approval. ReAct loop included.
Mobile workflow engine
Run durable workflows on iOS and Android via Rust + UniFFI. Offline-first, battery-aware. Server dashboard monitors mobile instances in real time. Human-in-the-loop approvals flow through silent push notifications.
200+ integrations via Activepieces
Slack, Gmail, Sheets, Stripe, GitHub, HubSpot, Notion, Discord — use any Activepieces connector as a workflow step with ap://piece.action. Zero custom code.
SSE streaming + plugin runtime
GET /instances/{id}/stream pushes block outputs in real time. WASM plugins run sandboxed handlers. gRPC sidecar plugins via grpc:// prefix.
Encryption at rest
Set ORCH8_ENCRYPTION_KEY to enable AES-256-GCM encryption on all sensitive context fields. Zero code changes required.
Multi-tenancy + API auth
X-Tenant-Id header enforcement with cross-tenant rejection. Optional API key auth. Per-tenant rate limiting and instance quotas.
Official SDKs & CLI
Three typed client SDKs (Node.js, Python, Go) covering 75-80 methods each. CLI for terminal-first workflows. Polling workers with heartbeats, circuit breaker awareness, and exponential backoff.
Performance
High performance. Measured, not claimed.
Rust engine, PostgreSQL storage, zero garbage collection pauses. These numbers come from our automated throughput test suite running against a single-node debug build — release builds are faster.
2,400+
instances/sec
Batch creation throughput
<3ms
per instance
Under 100 concurrent creates
1.04x
degradation
After 1,000 sequential runs
85ms
total
50 parallel DB operations
Throughput test results — single node, debug binary, PostgreSQL 16
Benchmarks run on every CI push. Source: performance_load.test.ts
Integrations
200+ connectors. One prefix.
Orch8 ships with native Activepieces integration. Use any community connector as a workflow step — no custom code, no adapter layer. Just prefix your handler with ap://.
// Send a Slack message in one step
{
"handler": "ap://slack.send_channel_message",
"params": {
"auth": { "access_token": "credentials://slack-bot" },
"props": { "channel": "#alerts", "text": "Deploy complete." }
}
}
// Insert a Google Sheets row
{
"handler": "ap://google-sheets.insert_row",
"params": {
"auth": { "access_token": "credentials://google-oauth" },
"props": { "spreadsheet_id": "1Bxi...", "values": ["Alice", "alice@co.com"] }
}
}Available connectors include
Dynamic loading
Pieces are installed on first use. No need to rebuild or redeploy when adding new connectors.
Full engine features
Retry, timeout, circuit breaker, credential resolution — all work identically with Activepieces steps.
Credential integration
Use credentials:// URIs in auth params. The engine resolves secrets at dispatch time, with OAuth2 auto-refresh.
Patterns
22 real-world patterns
Each pattern includes a problem statement, solution, and a copy-paste sequence definition.
Never Lose a Payment to a Provider Outage
Try Stripe, catch and try Braintree, catch and try Adyen. Sequential failover with idempotency keys — never double-charge.
Email Campaigns That Don't Get You Blacklisted
Send windows, mailbox rate limits, A/B subject lines, business-day delays with jitter.
Let an AI Agent Think, Act, and Loop
Loop until done, dispatch tools via router, feed results back — with iteration cap and crash safety.
Recover Failed Payments Without Losing Customers
Retry on schedule, human review for high-value accounts, SLA alert if resolution takes too long.
Stop Hammering a Broken API
Circuit breaker opens after N failures, short-circuits instantly. Serve cache or reschedule.
Update Live Workflows Without Restarting Them
Deploy v2, deprecate v1, migrate running instances. Completed steps keep their memoized outputs.
Templates
Copy, customize, deploy
Production-ready workflow definitions. Each includes the full sequence JSON, credential setup, trigger configuration, and customization guide.
SaaS Customer Onboarding
Welcome email, activation check, engagement branching, A/B subject lines, churn alert, CRM update. 14-day drip.
AI Support Triage
LLM classifies urgency and category, routes to the right Slack channel, escalates on SLA breach. Human review for edge cases.
Invoice Processing
LLM extracts line items from email, human approves high amounts, posts to accounting API. Retry with exponential backoff.
Block types
10 composable blocks
Blocks nest arbitrarily. A parallel block can contain try-catch blocks, which contain steps with retries.
Execute a single handler — built-in or external
Send email, call API, process payment
Run N branches concurrently, wait for all
Send to email + SMS + Slack simultaneously
Run N branches, first to complete wins
Try primary provider, fallback wins if faster
Conditional branching — if/else/switch
Route by user segment, plan tier, A/B test
Error recovery with optional finally
Try SMTP, catch with SES, always log result
Repeat while a condition is true
AI agent ReAct loop, poll until ready
Iterate over a collection
Process each item in a batch
Invoke another sequence as a child — parent waits
Compose reusable flows, modular campaign stages
Weighted traffic split — deterministic A/B routing
Test two onboarding flows, measure conversion
Protect blocks from cancel signals until complete
Payment capture, account suspension — never half-done
Built-in handlers
12 handlers out of the box
Handlers run inside Step blocks. Use built-ins or register your own via the REST worker API.
Call any LLM provider (OpenAI, Anthropic, etc.)
Dispatch to any registered handler by name
Pause for human approval with timeout
Make HTTP calls with retry and timeout
Inject or replace blocks at runtime
Fire events to trigger other sequences
Send signals to other running instances
Read state of another instance
Wait for a duration (distinct from delay)
Write to structured audit log
Intentionally fail for testing/branching
No-op placeholder for conditional logic
Triggers
4 trigger types
Triggers start sequence instances automatically when external events arrive. Each trigger binds to a sequence and creates instances on fire.
HTTP POST with optional HMAC signature validation. Map request body to instance context.
Subscribe to NATS subjects. Messages become instances. Supports wildcards and queue groups.
Watch filesystem paths for changes. Fire on create, modify, or delete events.
In-process event bus. Fire via API or from workflows using emit_event handler. No HMAC — trusted internal use.
Signals
Control running instances
Send signals to running instances via the API. Built-in signal types are handled automatically. Custom signals are dispatched to interceptors.
Suspend execution. Instance stays in memory, resumes on resume signal.
Continue a paused instance from where it stopped.
Terminate execution. Respects CancellationScope blocks.
Replace instance context mid-execution. Payload is the new context.
User-defined signals with arbitrary payloads. Dispatched to on_signal interceptor.
Pricing
Self-host free. Let us run it when you scale.
Same engine, same features. The only difference is who manages the infrastructure.
Self-hosted
Run on your own infrastructure. Full engine, no feature gates.
- ✓Unlimited sequences & instances
- ✓All block types & handlers
- ✓Single binary or Docker
- ✓Community support (GitHub)
- ✓BUSL-1.1 license
Starter
250K executions/mo, 5 seats, 30-day retention.
- ✓Everything in Self-hosted
- ✓Managed PostgreSQL & backups
- ✓Dashboard & observability
- ✓Email support (24h response)
Pro
2M executions/mo, unlimited seats, priority support.
- ✓Everything in Starter
- ✓Auto-scaling & high availability
- ✓Priority support with SLA
- ✓90-day data retention
- ✓99.9% uptime SLA
Enterprise
Dedicated infrastructure, OEM license, custom limits.
- ✓Everything in Pro
- ✓OEM / white-label license
- ✓Dedicated worker pool
- ✓Custom integrations
- ✓Priority support & SLA
- ✓Volume pricing
All plans include the full engine with no feature gating. BUSL-1.1 licensed. Need to embed Orch8 in your SaaS? Get a commercial license.
Roadmap
What's next
The engine is production-ready. Here's what we're building next.
Developer Experience
- ✓
Orch8 Cloudshipped
Managed hosting — zero ops
Sequence linter
Validate definitions before deploy
Test suite
Jest-like e2e runner for sequences
VS Code extension
Autocomplete, inline validation, go-to-definition
Platform
- ✓
Mobile SDK (iOS + Android)shipped
Offline-first workflow execution on mobile via Rust + UniFFI
Mobile sync + approvals
Server visibility into mobile workflows, push-driven sync
Visual sequence builder
Drag-and-drop constructor with live preview
OpenTelemetry export
Traces and spans for every step execution
Ecosystem
Plugin marketplace
Community-contributed handlers
Webhook debugger
Replay failed deliveries, inspect payloads
Ship product, not infrastructure
Define your workflows. Let the engine handle scheduling, retries, rate limits, and crash recovery.