- Category
- Developer Tools
- Rank
- No. 1396Tools index
Previous survey · No. 1365 ·
- Pricing
- Open Source
- Type
- TOOL
- Use case
- Agent Building
- GitHub
- 67 stars
- Latest release
- pulse-v1.0.0
- Date
About
Trigora is a durable execution platform for long-running AI agents and programs. Developers write normal application logic and Trigora checkpoints it for fault tolerance, without replaying event history to recover. It has TypeScript, Python and Rust components.
At a glance
Trigora resumes interrupted programs from saved execution state. It is worth evaluating for an agent or workflow that spends time waiting for timers, events or external work and needs to survive a worker restart.
Good fit
Developers who can test restart behavior around a small workflow with well-defined effects.
Consider something else when
Use a simpler scheduler for independent jobs that can safely start over.
Start here
Build a test workflow with a saved result followed by a timer. Restart the worker while it waits and verify that execution resumes with the expected state.
Cost and requirements
The repository documents SDKs for TypeScript, Python and Rust and offers a hosted option. Budget for storing and operating the execution state in your chosen setup.
Limits to know
Saved state covers the workflow runtime. Verify what happens if an external effect succeeds just before a failure, and make that operation safe to retry.
Sources checked 2026-11-05. Source-based assessment.
Read the source review
What it does
Trigora keeps long programs alive through crashes: AI agents that call models, wait on a person, or sleep for days. At each pause point it saves a snapshot of where the program stopped plus the data it needs next. After a failure it reloads that snapshot directly, where replay-style systems re-run the recorded history to rebuild state. This repository holds the command-line tool, a local runtime for development, and Pulse, a host for running workloads on your own servers. The core engine and the per-language SDKs live in separate repositories.
Why it's ranked here
The recovery design is a real difference from replay-based rivals, and the code shown backs its safety claims. The self-hosted host journals each side effect, refuses to resume when a recorded input no longer matches, and uses time-limited ownership claims so two workers cannot run the same execution. The tooling is MIT licensed. Against that: the engine underneath is source-available under the Business Source License, and the headline recovery time of 0.06 milliseconds is the project's own number, with no benchmark among the files read. A promising architecture from a single vendor, with real licensing terms to read before adopting.
What's good
The durability rules are explicit and visible in code. The self-hosted host ships stated defaults: four workers, a cap of 64 executions, a two-second side-effect timeout, a 60-second ownership lease and two attempts per side effect. On resume, a side effect that already finished and was recorded is answered from the journal instead of being called again. The host refuses to start without a durability token unless you pass an ephemeral flag, and that mode prints a warning that state will be lost; tests check both paths. Local development stores state in a SQLite file and resumes waiting executions when restarted.
Tradeoffs
The license split matters if you ship it: the tooling is MIT, yet distributed binaries link the engine, which stays under the Business Source License until it converts to Apache 2.0. The command tool's build expects a sibling checkout of the engine repository or the published crates, so this repository does not build on its own. The host gives the engine 65,536 instructions per call and treats running out as a failure, so long pure-compute loops between durable steps need to sit inside a side effect. Test fixtures label the TypeScript frontend a language subset, and the host's tests run over Unix sockets.
How to use it well
Fits teams building agents or approval flows that wait hours or days on people, webhooks or timers, where a crash should cost one step rather than the whole run. Start with the local runtime, which needs Node.js 22 or 24 for TypeScript programs; stop it mid-wait and restart it to watch executions resume. Keep side-effect inputs deterministic, since a changed input on resume fails the run. Use ephemeral mode only for experiments. It is the wrong tool for short stateless jobs a plain queue already handles, and teams that need open-source licensing end to end should read the engine terms first.
Technical notes+
Cargo.toml defines a three-crate Rust workspace (trigora-local, trigora-cli, trigora-pulse). crates/trigora-cli/Cargo.toml builds three binaries (trigora, trigora-local, tcc-rust-compile) and pins the tcc-core, tcc-host, tcc-host-sqlite, tcc-ir, tcc-state and Rust frontend crates at 26.10.4 with path entries pointing at a sibling tcc-engine checkout. crates/trigora-cli/src/dev/mod.rs spawns the trigora-local binary with a SQLite database under .trigora in the project root, default host 127.0.0.1 and port 3477, a loopback effect server guarded by a random secret, and a 30-second wait for a ready event; file changes are watched and programs re-pushed. crates/trigora-pulse/src/drive.rs runs the engine with a BUDGET of 65_536 per run_until_host call, maps BudgetExhausted to a failed step, rejects an effect whose encoded input differs from its journal row, answers completed or failed journal rows without dispatching, acks RegisterTimer and RegisterWait inline, and emits a Commit at PersistCheckpoint only when the revision follows the confirmed one. crates/trigora-pulse/src/supervisor/mod.rs sets Config defaults (workers 4, cap 64, effect_timeout 2s, lease_ms 60000, max_effect_attempts 2) and starts a recovery loop only when the authority has a remote. crates/trigora-pulse/tests/startup.rs asserts exit code 2 with no durability token, the ephemeral-mode warning, protocol 1 over length-prefixed JSON frames on a Unix socket with bearer auth, and uses a fixture tagged ts.subset.v1. LICENSE_NOTICES states TCC Engine components are BSL 1.1 and not relicensed under MIT.
Observed
- License
- MIT for the CLI, local runtime, Pulse host and contracts; linked TCC Engine components under Business Source License 1.1
- Language
- Rust workspace (CLI, local runtime, Pulse host) plus a TypeScript contracts package
- Packaging
- npm, pip and cargo packages per the README; Pulse distributed as a container image on GitHub Container Registry
- Interfaces
- CLI (init, dev, deploy, start, send, cancel, inspect, result, whoami), HTTP API, and a Unix-socket adapter protocol for Pulse
- Platform support
- Pulse images for Linux AMD64 and ARM64; Node.js 22 or 24 required by the workspace engines field
- Build dependency
- CLI crate resolves engine crates from a sibling tcc-engine checkout or the published crates
- Engine instruction budget
- 65,536 instructions per engine call in the Pulse driver; exhaustion fails the execution
- Continuation size limit
- Serialized continuations up to 16 MiB on Pulse (README)
- Tests
- Pulse startup integration tests in crates/trigora-pulse/tests/startup.rs
Read from README.md, Cargo.toml, package.json, crates/trigora-cli/Cargo.toml, crates/trigora-cli/src/main.rs, crates/trigora-cli/src/commands.rs, crates/trigora-cli/src/dev/mod.rs, crates/trigora-local/src/runtime/mod.rs, crates/trigora-local/src/lib.rs, crates/trigora-pulse/src/lib.rs, crates/trigora-pulse/src/supervisor/mod.rs, crates/trigora-pulse/src/drive.rs, packages/contracts/src/index.ts, LICENSE_NOTICES, crates/trigora-pulse/tests/startup.rs.
Tags
Tech Stack
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.