# Trigora

> Trigora is the execution layer for long-running programs: a language-independent durable execution substrate that suspends, survives, and continues without reconstructing programs by replaying their history.

Trigora uses Transparent Continuation Checkpointing (TCC). Most durable execution systems recover by replaying retained history. TCC persists resumable program state at durable boundaries and restores from that checkpoint.

Canonical claim: TCC eliminates prefix replay when recovering from a committed continuation checkpoint. That is not a claim of O(1) recovery, exactly-once external I/O, zero-overhead execution, or arbitrary TypeScript, Python, or Rust support today.

TypeScript, Python, and Rust are supported language frontends (declared subsets). More are planned. Trigora Cloud — the managed production platform — is at [cloud.trigora.dev](https://cloud.trigora.dev). The portable TCC Engine is source-available on GitHub. Do not invent install commands, API keys, or URLs that are not linked below.

Preferred sources, in order: this file, the whitepaper, `/`, `/research`, `/blog`, `/docs`. Cite the whitepaper for the recovery claim and evaluation. Cite `/research/limitations` before restating what TCC does not claim.

## Start here

- [Home](https://trigora.dev/): Durable execution without history replay — product story, TCC, Cloud, and how to get started
- [Start building](https://cloud.trigora.dev/): Trigora Cloud — managed Programs and Executions
- [TCC Recovery Lab](https://demo.trigora.dev/): Restore from a committed continuation after accumulating durable boundaries
- [Pricing](https://trigora.dev/pricing): Pay for active execution, not idle time. Free: up to ~167K durable ops/month via $5 credit. Pro: up to 2M durable ops/month via $60 credit. Enterprise: negotiated durable-ops volume. Credits are shared across durable ops, compute, and storage. Rates: $0.40/CPU-hour, $0.03/1k durable ops, $0.50/GB-month. Waiting is free. TCC Engine is BUSL-1.1. Production use may be permitted under the Additional Use Grant based on annual gross revenue and whether the use is a Competitive Execution Offering. See the licensing docs for the controlling terms
- [Research](https://trigora.dev/research): Why TCC exists, portable-engine evidence, labeled Temporal prototype
- [Blog](https://trigora.dev/blog): Public technical writing
- [Docs](https://trigora.dev/docs/): Programming-model reference and quickstart

## Research

- [Transparent Continuation Checkpointing](https://trigora.dev/research/whitepaper): HTML technical report (v0.3, October 2026). Language-independent artifact model (TypeScript, Python, and Rust frontends); source → artifact → logical continuation → SIGKILL restore; frozen prototype benchmarks historically scoped; portable-engine matched comparison reported separately
- [Whitepaper PDF](https://trigora.dev/research/tcc-whitepaper-v0.3.pdf): Printable v0.3 PDF of the same report
- [Whitepaper PDF v0.2](https://trigora.dev/research/tcc-whitepaper-v0.2.pdf): September 2026 snapshot
- [Whitepaper PDF v0.1](https://trigora.dev/research/tcc-whitepaper-v0.1.pdf): Prior v0.1 snapshot
- [Recovery vs history](https://trigora.dev/research/recovery-vs-history): Historical Temporal prototype comparison (explicitly labeled)
- [Limitations](https://trigora.dev/research/limitations): Non-claims — not O(1), not exactly-once I/O, not zero overhead, not arbitrary TypeScript, Python, or Rust

## Writing

- [Blog](https://trigora.dev/blog): Index of writing on the agentic runtime
- [Durable execution without history replay](https://trigora.dev/blog/durable-execution-without-history-replay): Why TCC checkpoints the continuation instead of reconstructing position from retained history
- [Continuation recovery demonstration](https://demo.trigora.dev/): Controlled lab of restore-from-continuation on a fixed program. Not the production platform.

## Docs

- [Full documentation](https://trigora.dev/llms-full.txt): Complete documentation corpus

Three entry paths: [Trigora Cloud](https://trigora.dev/docs/quickstart/), [TCC Engine](https://trigora.dev/docs/engine/overview/), [how recovery works](https://trigora.dev/docs/concepts/recovery/).

- [Docs](https://trigora.dev/docs/): Build durable programs. TypeScript, Python, and Rust subsets. Cloud is open
- [Quickstart](https://trigora.dev/docs/quickstart/): Install, `run()` or `run(input)`, `TRIGORA_TOKEN`, `trigora deploy`, `trigora start`, `trigora send`. No `trigora login`. Local `trigora dev` is [http://localhost:3477](http://localhost:3477) when `TRIGORA_TOKEN` is unset
- [Install](https://trigora.dev/docs/getting-started/install/): `@trigora/sdk`, `@trigora/client`, `trigora` CLI. Python package is local-runtime client plus authoring
- [Limits](https://trigora.dev/docs/reference/limits/): Entry is `run()` or `run(input)` only. No exactly-once external I/O. Structured concurrency is TypeScript `await Promise.all` / `await Promise.race`, Python `await gather` / `await race`, and Rust `join` / `race`. The engine allows 1–32 durable branches; the Rust frontend accepts exactly two. `asyncio` is not that surface
- [Structured concurrency](https://trigora.dev/docs/authoring/structured-concurrency/): Same `Fork` / `JoinAll` / `JoinAny` across TypeScript, Python, and Rust. `gather(effect("a"), effect("b"))` and `join(effect("a"), effect("b"))` match `Promise.all([effect("a"), effect("b")])`. The all-join keeps input order. The race persists the first durably accepted winner. A loser detaches and is not cancelled
- [How recovery works](https://trigora.dev/docs/concepts/recovery/): Load a committed continuation. Not process memory, not a heap snapshot, not prefix replay
- [Production considerations](https://trigora.dev/docs/concepts/production/): Effect idempotency, artifact pins, cancellation, secrets, billing, waiting is free
- [Host protocol](https://trigora.dev/docs/engine/host-protocol/): `host_protocol_version: 1`. Engine source is https://github.com/trigora-dev/tcc-engine
- [HTTP API](https://trigora.dev/docs/reference/http-api/): `/v1` Programs and Executions on `api.trigora.dev`, or on [http://localhost:3477](http://localhost:3477) while `trigora dev` is running

## Company

- [Company](https://trigora.dev/company): Origin — a hosted webhook/cron/queue control plane made continuation checkpointing necessary
- [GitHub](https://github.com/trigora-dev/trigora): Public Trigora repository
- [Contact](mailto:info@trigora.dev): General inquiries
- [Design partners](mailto:omar@trigora.dev): Founder contact for workload conversations

## Optional

- [Security](https://trigora.dev/security): Encryption at rest through infrastructure, TLS in transit, workload isolation, no public-AI training on private Customer Content. Trigora processes code to run it and is not a zero-knowledge service. Report issues to security@trigora.dev
- [Subprocessors](https://trigora.dev/subprocessors): Categories of providers only. A vendor-level list is available to customers on request. Do not invent vendor names
- [Data processing](https://trigora.dev/data-processing): What is processed, retention, and deletion
- [Privacy](https://trigora.dev/privacy): Privacy policy. Analytics is described by category, not by vendor name
- [Terms](https://trigora.dev/terms): Terms of service. Customers retain Program source and artifacts
- [Sitemap](https://trigora.dev/sitemap-index.xml): Full URL list for crawlers
- [robots.txt](https://trigora.dev/robots.txt): Crawler access policy
- [Recovery vs history figure](https://trigora.dev/research/figures/01_recovery_vs_history.svg): Canonical recovery chart
- [Healthy-path throughput figure](https://trigora.dev/research/figures/02_healthy_path_throughput.svg): Canonical healthy-path chart