Toren runs agents
that work for days,
do real work,
and survive anything.

Kill it. It keeps working.

Every model call and tool call is recorded in a Postgres event log the moment it completes. The run's state is the log, so nothing that lives in a process can die with one.

One agent. Every surface.

Agents as durable processes: files define the agent once, then run it, schedule it, talk to it, let a conversation launch its background jobs. All of it rides one event log; kill any of it and nothing re-pays. Parked work costs nothing: not a worker, not a container, not a poll loop.

export default async function (ctx) {
  // one planner task; the model decides
  // what deserves research
  const plan = await ctx.wave("plan",
    [ctx.task("planner", ctx.input)]);

  // your code turns the plan into a
  // dynamic parallel fan-out
  const topics = parse(plan.results[0].output);
  const found = await ctx.wave("research",
    topics.map(t => ctx.task("researcher", t)),
    { onTaskFailure: "collect" });

  // park for a human: zero compute
  const memo = await ctx.wave("write",
    [ctx.task("writer", join(found))]);
  return memo.results[0].output;
}

effects: "external",
// recorded once, never re-run
idempotency: "keyed",
// retries carry a stable key
approval: "always"
// parks until a human signs

const t = new TorenClient({url, token});
const {runId} = await t.startRun({input});
const run = await t.waitForRun(runId);

$ toren dev
→ console: localhost:7433/console
live runs · event timelines
one-click approvals · API keys
# pre-authed link, zero setup

$ toren dev --dir crews/
serving 3 agents (research,
  support, billing)
each crew: own event log,
own schema, shared nothing

you> run the weekly report
agent> Started. I'll message
       you when it lands.
# parked at $0 · survives anything
agent> Report's ready: 42 pages.

$ toren schedule create
    --process daily-digest
    --cron "0 8 * * *"
# fire records survive any crash;
# one occurrence, one run, ever

sandbox: true
# bash + files, a real workspace
kill the worker mid-build:
the successor reconnects the
same workspace and keeps going

One runtime underneath: the same durable substrate runs your chat assistant, your overnight coding job, your scheduled pipelines, and the background runs a conversation spawns. Different shapes of agent, one guarantee.

The alternative is a stack you assemble yourself.

A framework for the agent, a workflow engine for durability, a sandbox vendor for the computer, glue for the rest. Every seam is yours to build and yours to debug at 3am.

Six systems with six failure modes, or one runtime on one Postgres event log, where a kill -9 anywhere loses nothing.

One dependency locally. Your AWS in production.

Open source, forever.

Everything the runtime does is Apache-2.0. Features never move behind a paid tier: the full runtime, the CLI, the console, the AWS deploy, approvals, scheduling, the API and SDK.