Built on TCC

Durable execution
without history replay.

Run long-lived AI agents and programs that recover from where they left off without replaying completed execution history.

Start building → View TCC Engine

Read the technical report

TCC The engine behind durable execution.

Continue

TCC

Checkpoint what matters. Continue from there.

TCC commits the program position and live state needed to resume. After failure, execution continues from that committed point instead of replaying completed history.

0.06 ms vs 336 ms at 5,000 steps

Read the technical report →

Fault injection

Kill it at every checkpoint.

Crash the program after committed durable boundaries, resume it, and verify that recovery matches the baseline without duplicate or missing effects.

Measure checkpoint cost, continuation size, and restore latency with trigora bench.

Learn about verification →

trigora verify

$ trigora verify order-agent --faults all

Trigora verify — order-agent

Recovery
  Fault points tested       1,284 / 1,284
  Successful recoveries     1,284
  Failed recoveries         0
  Duplicate effects         0
  Median recovery           1.2 ms

✔ Recovery verified at every checkpoint

Example verification output.

Software is becoming long-lived.

Agents don't execute like requests. They branch, wait, call tools, coordinate children, accumulate state, and survive across hours or days.

They need an execution substrate designed for that lifetime.

hours-days
human waits
tool calls
child executions
persistent state

Write. Deploy. Suspend. Resume.

Trigora Cloud takes programs from authoring to production recovery without asking you to operate a durability coordinator.

Write

Ordinary programs with explicit durable boundaries.

Deploy

Ship Programs to Trigora Cloud from the CLI.

Suspend

Waits and child joins release compute; state stays committed.

Resume

Recover from the continuation without replaying completed history.

How Trigora works →

Durable operations, explicit boundaries.

Effects, waits, timers, and child executions create durable boundaries. TCC commits the live continuation there, so recovery resumes from state instead of reconstructing the completed prefix.

effect Durable external work
invoke Durable child execution
waitForEvent Suspend without holding compute
sleep Durable timers across restarts

The same durable program, written as ordinary code in each language.

@trigora/sdk


          import { effect, waitForEvent } from "@trigora/sdk";

export default async function researchAgent(topic: string) {
  const report = await effect("research", async () => research(topic));

  await waitForEvent("approved");

  return effect("publish", async () => publish(report));
}

import { effect, waitForEvent } from "@trigora/sdk";

export default async function researchAgent(topic: string) {

const report = await effect("research", async () => research(topic));

await waitForEvent("approved");

return effect("publish", async () => publish(report));

}


          from trigora import effect, program, wait_for_event

@program
async def research_agent(topic):
    report = await effect("research", lambda: research(topic))

    await wait_for_event("approved")

    return await effect("publish", lambda: publish(report))

from trigora import effect, program, wait_for_event

@program

async def research_agent(topic):

report = await effect("research", lambda: research(topic))

await wait_for_event("approved")

return await effect("publish", lambda: publish(report))


          use trigora::{effect, wait_for_event};

pub async fn main(topic: String) -> Result<String, String> {
    let report: String =
        effect("research", move || research(topic)).await?;

    let _approval: String =
        wait_for_event("approved").await?;

    effect("publish", move || publish(report)).await
}

use trigora::{effect, wait_for_event};

pub async fn main(topic: String) -> Result<String, String> {

let report: String =

effect("research", move || research(topic)).await?;

let _approval: String =

wait_for_event("approved").await?;

effect("publish", move || publish(report)).await

}

Language-native authoring.

Start with TypeScript, Python, and Rust. TCC is designed for additional language frontends over time.

Supported

Planned

Run TCC your way.

Embed the portable engine in your own infrastructure, or use Trigora Cloud as the managed production host.

Embed TCC Engine

Use the portable engine, reference hosts, host protocol, and conformance kit in your own stack.

portable engine
reference SQLite host
host protocol v1

View TCC Engine →

Trigora Cloud

Deploy and operate durable programs without running the execution infrastructure.

managed runtime
deploy
observe
integrate

Start building →

Recovery cost follows live state, not completed history.

With ~4 KB of live state, TCC recovery stayed roughly flat from 10 to 5,000 completed history entries. Matched history replay grew with the completed prefix.

Portable TCC Engine vs matched history replay Methodology →

Portable TCC Engine vs matched history replay · ~4 KB live continuation · linear Y-axis

Live state, not history

After thousands of steps, recovery stays near-instant. TCC continues from live state, so cost tracks what is active now, not how long the run has been going.

Live state still sets the cost

At 5,000 completed steps, the same recovery moved from about 0.065 ms at ~4 KB of live state to about 0.285 ms at ~64 KB. The completed prefix stayed fixed.

tcc-engine 26.10.0 · Apple M1 Pro · Node 22 · local reference host

Built for workloads that shouldn't be replayed.

Long-running agents

Tools, retries, and state that must survive hours or days.

Human-in-the-loop

Approval waits that should consume no active compute.

Multi-agent orchestration

Child executions, joins, and cancellation without recreating work.

Branching programs

Loops and conditionals that change shape as they run.

Start building → Read the docs

Durable executionwithout history replay.