Coming Soon
The Runtime for "AI Workflows"
Durable execution primitives for AI agents and data pipelines. Survive crashes, retries, and timeouts — without managing infrastructure.
pipeline.ts
import { workflow, step } from "lumi0";
export const processPipeline = workflow({
id: "data-pipeline",
steps: [
step("validate", async ({ input }) => {
const schema = z.object({ url: z.string().url() });
return schema.parse(input);
}),
step("fetch", async ({ prev }) => {
const res = await fetch(prev.validate.url);
return res.json();
}),
step("transform", async ({ prev }) => {
return prev.fetch.items.map(normalize);
}),
step("store", async ({ prev, retry }) => {
await db.batch(prev.transform, { retry });
}),
],
});run_01j9xkm2p4 · live trace
waiting...
Trusted by
Reliability.
Not plumbing.
Production AI workflows fail. Steps time out, APIs return errors, servers restart mid-execution. Building retry logic, state persistence, and observability from scratch wastes weeks. Lumi0 ships it.
handler.ts
// Without Lumi0: manual retry loops, lost state, no observability
async function processOrder(orderId: string) {
let attempts = 0;
while (attempts < 3) {
try {
const order = await db.getOrder(orderId); // crashes here?
const payment = await stripe.charge(order); // retried twice?
await email.send(order.email, payment); // sent 3 times?
await inventory.decrement(order.items); // state unknown
break;
} catch (err) {
attempts++;
await sleep(attempts * 1000); // hope it works
if (attempts === 3) throw err;
}
}
// Where did it fail? No idea.
// Was the customer charged? No idea.
// Did the email send? No idea.
}Every step persisted.
Every retry safe.
Lumi0 checkpoints state after each step. On failure, execution resumes from the last successful checkpoint — not from scratch. No duplicate charges. No lost data.
StepTimelineDuration
workflow.start
1ms
step: validate_input
12ms
step: fetch_user
89ms
step: call_llm
1.4s
step: call_llm
↻ retry #1 — timeout
step: store_result
34ms
step: send_webhook
67ms
workflow.complete
total: 2.8s
Exactly-once execution
Steps never run twice even after crash recovery.
Automatic checkpointing
State saved after every successful step.
Safe retries
Retry individual steps without replaying the workflow.
Everything your
workflow needs.
query"user's billing question"
results[3 relevant memories]
write"resolved - upgraded plan"
memory.search / memory.write
Persistent context
Store and retrieve semantic memories across workflow runs. Agents remember users, decisions, and outcomes without you managing a vector DB.
model"gpt-4o"
prompt{{steps.search.results}}
outputstring (persisted)
llm
LLM as a step
Call any model as a first-class workflow step. Swap providers without rewriting logic. Outputs are typed, persisted, and replayable.
fnstripe.charge()
retry3x with backoff
result{ status: 'paid' }
tool
Durable function calls
Execute external APIs, database queries, or application functions as retryable, idempotent steps. Failures never lose state.
ifscore > 0.85
→step('escalate')
elsestep('auto-reply')
condition
Branching logic
Route execution based on step outputs, model decisions, or application state. Build arbitrarily complex decision trees in pure TypeScript.
attempt 1/3503 → wait 2s
attempt 2/3503 → wait 4s
attempt 3/3200 ✓ persisted
retry config
Per-step retry policies
Configure backoff, max attempts, and deadlines per step. Lumi0 retries from the exact failure point — no duplicate side effects.
steps.fetch{ user: {...} }
steps.respond"Here's how to..."
statusRUNNING → step 3/4
workflow state
Durable step outputs
Every step output is checkpointed after completion. Server restarts, deployments, and crashes never lose workflow progress.
Define workflows
in code.
01
Define
Declare your workflow as a graph of typed steps. Pure TypeScript — no YAML, no DSL. Full autocomplete on every step output.
02
Execute
Trigger from an API route, webhook, cron job, or CLI. Lumi0 handles scheduling, retries, and state persistence automatically.
03
Observe
Every run has a structured audit trail. Query step outputs, replay from any checkpoint, or stream events to your logging system.
customer-support.ts
import { workflow, step } from "lumi0";
import { openai } from "@lumi0/openai";
export const customerSupport = workflow({
id: "customer-support",
steps: [
step("search", async ({ input }) => {
return memory.search({
query: input.message,
userId: input.userId,
limit: 5,
});
}),
step("respond", async ({ prev, input }) => {
return openai.chat({
model: "gpt-4o",
messages: [
{
role: "system",
content: "You are a support agent. Context: " +
JSON.stringify(prev.search.results),
},
{ role: "user", content: input.message },
],
});
}),
step("save", async ({ prev, input }) => {
return memory.write({
userId: input.userId,
content: prev.respond.content,
metadata: { type: "support-response" },
});
}),
],
});
// Trigger from anywhere
const run = await lumi0.run(customerSupport, {
input: { userId: "u_123", message: "How do I upgrade?" },
});See exactly
what happened.
Every run produces a full structured trace. Inspect step outputs, replay from any checkpoint, or export events to Datadog, Grafana, or any OTEL-compatible backend.
COMPLETEDrun_01j9xkm2p4
workflow: research-agentstarted: 10:42:01 UTCended: 10:42:03 UTC
StepTimeline (relative)Duration
validate_input
12ms
fetch_user
89ms
call_llm
1.4s
store_result
34ms
send_webhook
67ms
5 steps · 0 retries · 0 errorsTotal: 1.602s
Agents that
don't time out.
LLM-based agents often run for minutes or hours. Lumi0 lets them run as long as they need — every tool call is a durable step, every loop iteration is a checkpoint.
- →Each agent step is a durable checkpoint — LLM calls, tool calls, everything.
- →Agents can spawn sub-workflows and wait for their completion.
- →Loop until a condition is met — without holding a server thread.
- →Full execution trace for every agent run, including intermediate tool calls.
- →Cancel or pause any agent run in flight.
agent-architecture.txt
┌──────────────────────────────────┐
│ Agent Orchestrator │
│ workflow("autonomous-agent") │
└────────────┬─────────────────────┘
│
┌──────────▼──────────┐
│ step("plan") │
│ model: gpt-4o │
│ ✓ persisted │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ step("tool_call") │◀── loop until done
│ tool: web.search │
│ ✓ idempotent │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ step("reflect") │
│ model: gpt-4o │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ step("output") │
│ → stored result │
└─────────────────────┘Built for the
real world.
AI Research Agent
Multi-step reasoning over web sources with LLM summarization.
plan→
search ×N→
synthesize→
store
Order Processing
Charge, fulfill, notify — exactly once, even after a crash.
validate→
charge→
fulfill→
notify
Data Pipeline
Extract, transform, load with per-step retry and observability.
extract→
validate→
transform→
load
Document Processing
Parse, embed, and index documents at scale.
parse→
chunk→
embed→
index
Scheduled Digest
Morning email digest from multiple feeds, generated by an LLM.
fetch-feeds→
summarize→
render→
send
Stop maintaining.
Start shipping.
Every tool below is something teams spend weeks setting up and months maintaining. Lumi0 replaces all of it.
Eliminated
✗Redis queues
✗BullMQ workers
✗pg-boss tables
✗Temporal clusters
✗Airflow DAGs
✗Celery beat
✗cron daemons
✗dead-letter queues
✗idempotency middleware
✗retry decorators
✗state machines
✗saga coordinators
Lumi0 Runtimeimport from "lumi0"
⬡
Durable Execution
State persisted after every step.
↻
Smart Retries
Per-step retry policies with backoff.
◉
Live Observability
Structured trace for every run.
⌘
Idempotency
Exactly-once delivery by default.
⏱
Scheduling
Cron and delay triggers built in.
⬡
Sub-workflows
Compose workflows from workflows.