Can I run Causet locally today?

Yes. Install the CLI from install.causet.io, run the wallet demo with Docker, and use the local runtime without a cloud login.

Deterministic runtime · Compiler · Timeline

Turn fragile workflows into replayable timelines.

Q: What is Causet?

Causet is a deterministic application runtime and compiler for stateful business workflows. Your app submits intents; Causet records state transitions and business events on a timeline you can inspect and replay.

Q: Is Causet only for AI?

No. Causet is useful for any critical state transition — refunds, onboarding, disputes, and operational workflows where auditability and replay matter.

Causet sits beside your existing backend. Start with one endpoint, webhook, background job, or AI-agent action. Causet records deterministic state transitions and business events while your application code, database, APIs, and infrastructure stay in place.

Run Causet locally Read the retrofit guide

View the wallet demo

CLI and wallet demo available now · Managed Causet Cloud is early access

Concrete retrofit

Same endpoint. Clearer state.

Keep the public API. Move the fragile downstream work into Causet.

Logs tell you what code said. Causet shows how state changed.

Before

Fragile endpoint logic

Controller loads records
Business rules are mixed into application code
Side effects happen inline
Failures are reconstructed through logs

            
              After
              Intent in. Timeline out.
            
            Existing endpoint submits an intent
Causet validates the transition
State changes and events commit together
Projections and side effects run from committed events
The full timeline can be inspected

          

retrofit · POST /api/orders/:id/refund

// Keep the route. Hand the workflow to Causet. const result = await client.submitIntent( 'refund_stream', refund.id, 'REFUND_REQUESTED', { refund_id, order_id, amount, reason }, refund.id // idempotency key ); return Response.json({ status: 'accepted' }, { status: 202 });

Full walkthrough: Retrofit an endpoint →

How Causet works

Define the state changes. Causet records the timeline.

Author .causet models. The compiler validates them. The runtime executes transitions deterministically beside your app.

Existing app

Causet SDK / API

Deterministic runtime

State + event timeline

Projections / webhooks / query

01Intent

Your app, webhook, job, or agent asks for a change.

02Validate

Rules decide which transitions are legal.

03Commit

State and events land together on the timeline.

04Project

Readable views and callbacks update from events.

05Inspect

Debug the timeline instead of scattered logs.

06Replay

Inspect, fork, rebuild, or replay — with explicit isolation for side effects.

Causet is not

A replacement for the application database
A general-purpose message broker
A background-job queue
A workflow diagramming product
A requirement to rewrite the backend

            Causet is
            A deterministic runtime for stateful business workflows
A compiler-backed DSL
An immutable event and decision timeline
A way to retrofit durable execution into existing systems

          

Details: Mental model · What Causet handles

What you can run today

Start locally. Use Cloud when you need hosted runtimes.

Install the CLI and run the wallet demo locally. No cloud login required. Managed Causet Cloud is early access for approved customers.

Local quick start · Docker + Node 20+

curl -fsSL https://install.causet.io/install.sh | bash causet version causet doctor causet new wallets my-wallets cd my-wallets causet local up npm run dev --prefix app # open http://localhost:3850 manually

Supported production core

Available now with defined compatibility and support expectations for production workloads.

Capability	Availability	Maturity	Production use
Local CLI Install from the official installer. Checksum-verified releases on GitHub.	Available now	Production-ready	Supported
JavaScript / TypeScript SDK Published on npm (`@causet/sdk` 0.2.0, `@causet/sdk-node`, `@causet/sdk-next`). Primary API: `client.submitIntent()`.	Available now	Supported preview	Supported for pilots
Timeline inspection Inspect committed timelines via the CLI or the Decision Timeline UI in Managed Causet Cloud.	Available now	Production-ready	Supported
Read-only historical inspection View entity state at a cursor without re-executing rules. CLI and Entity Inspector scrubber.	Available now	Production-ready	Supported
Projection rebuild Rebuild read-model tables from the event stream. Handlers only — no side-effect risk.	Available now	Production-ready	Supported
Forking Branch from a cursor to explore repairs without touching production.	Available now	Production-ready	Supported
Inbound webhooks → intents Your app verifies provider payloads and submits intents. Works with local Docker runtime or Managed Causet Cloud.	Available now	Production-ready	Supported
Outbound HTTP webhooks Managed Cloud: supported for approved customers. Local Docker: available for development, disabled by default (`WEBHOOK_DELIVERY_ENABLED=false`), not production-supported.	Available now	Production-ready	Supported for approved customers

Controlled early access

Preview maturity, pilot-only production support, or approval-gated early access. Availability varies by capability.

Capability	Availability	Maturity	Production use
Managed Causet Cloud Hosted runtime with sandbox and production environments for approved customers. Decision Timeline UI and hosted replay tooling require Cloud.	Early access	Production-capable	Supported for approved customers
Python SDK Source on GitHub. PyPI publishing in progress. Supported for design-partner pilots.	Early access	Preview	Supported for pilots
Java SDK Source on GitHub. Maven Central publishing in progress. Supported for design-partner pilots.	Early access	Preview	Supported for pilots
PHP / Laravel SDK Laravel package source on GitHub. Packagist publishing in progress. Supported for design-partner pilots.	Early access	Preview	Supported for pilots
Go SDK `causet-sdk-go` source on GitHub. Supported for design-partner pilots.	Early access	Preview	Supported for pilots
Snapshot rehydration Rebuild entity snapshots from the ledger. Preview — may re-run rules; guard side effects with idempotency keys or `is_replay`.	Available now	Preview	Supported for pilots
Decision replay Forensics replay from a cursor. Preview — can re-fire side effects; use non-production forks.	Available now	Preview	Supported for pilots
Repair execution Apply inverse patches from a decision ID via `causet forensics repair-plan` / `repair-apply` in sandbox forks. Preview.	Available now	Preview	Supported for pilots

Local development and evaluation

Available today for local development, testing, demos, and evaluation. Not supported for production workloads.

Capability	Availability	Maturity	Production use
Local Docker runtime `causet local up` for development and evaluation. Does not include the Cloud control-plane UI.	Available now	Developer preview	Not supported
Wallet demo Local example for learning intents, state, events, timelines, and replay.	Available now	Demo	Not supported
Public SDK source — MIT All SDK language clients in `causet-sdks`. JavaScript / TypeScript packages are on npm; other languages are source-first.	Available now	Supported preview	Not supported
Public template source — Apache 2.0 Official templates and local starters in `causet-templates`.	Available now	Supported preview	Not supported
Public installer and release tooling Checksum-verified CLI installer at install.causet.io and versioned GitHub Releases artifacts.	Available now	Supported preview	Not supported

Coming soon

Planned capabilities that are not yet generally available.

Capability	Availability	Expected maturity	Production use
Full runtime source release Self-managed runtime source distribution. Public installer artifacts and SDK/template repos are available today.	Coming soon	Preview at release	Self-managed
Full CLI implementation source release Full CLI implementation source beyond published release artifacts and installer scripts.	Coming soon	Preview at release	Self-managed
Compiler source release Compiler source distribution for self-managed builds.	Coming soon	Preview at release	Self-managed
Rust SDK Additional language client planned beyond the current SDK line-up.	Coming soon	Planned	Not supported

Availability describes who can access a capability. Maturity describes its technical lifecycle. Production use describes the level of operational support Causet provides. Full details: What runs today?

Replay is not one button. Read-only inspection and derived-state rebuilding do not repeat external effects. Decision replay and repair paths require explicit isolation, idempotency, and side-effect controls. See the replay guide and What runs today?.

Primary use cases

Useful anywhere state changes matter.

AI agents are one path, not the only one. Causet is a timeline layer for critical backend workflows.

↳

Retrofit critical backend workflows

Wrap one fragile endpoint, webhook, or job. Keep the API contract and existing database.

≡

Financial and ledger-style transitions

Refunds, wallets, disputes, and balance changes that need deterministic commits and audit history.

⟳

Long-running operational processes

Multi-step onboarding, escalations, and retries where partial failure is expensive.

✦

AI-agent decisions with durable state

Record memory, decisions, tool calls, and business events on the same inspectable timeline.

Adoption path

Adopt Causet one workflow at a time.

No rewrite. Prove the pattern on one flow, then expand where replay and audit matter.

1. Keep the API and database

Routes and response shapes stay the same. Your DB remains the app-facing read model.

2. Submit one intent

Validate in the endpoint, then hand the fragile work to Causet.

3. Sync with projections or webhooks

Update app state from committed events when the workflow finishes.

4. Inspect, then expand

Debug the timeline. Move the next workflow only when the pattern pays off.

Retrofit an endpoint Read the docs

Built and runnable today

Installable tooling and public repositories.

Every item links to a surface you can verify yourself.

Official installer

Checksum-verified CLI from GitHub Releases. Current release: v10.0.12.

Local Docker runtime

causet local up starts runtime, API, query, projection, Postgres, Redis, and Redpanda.

Wallet demo

causet new wallets scaffolds a live UI. No cloud login.

Compiler and DSL

Validate and compile .causet models locally before you deploy.

Versioned CLI releases

Public CLI and compiler artifacts with SHA-256 checksums.

SDK packages and source

@causet/sdk 0.2.0 on npm; all languages in causet-sdks (MIT) Supported preview

Documentation

Mental model, retrofit guide, replay reference, and CLI docs.

Template repository

Official Apache 2.0 templates and local starters, including wallets.

SDK source repository

Public SDK source — MIT. JavaScript / TypeScript packages published on npm.

Design partners

Building a critical workflow?

Causet is working with a small number of engineering teams on new workflow designs, isolated pilots, and shadow-mode evaluations.

Run locally Read the retrofit guide

Keep your app. Move one fragile flow.

Run Causet locally, then retrofit one endpoint.

Install the CLI, explore the wallet demo, and add Causet beside a single workflow. Request Managed Causet Cloud when you need a hosted runtime with the control-plane UI.

Run locally Retrofit an endpoint Explore the wallet demo

· · Read the docs

FAQ

Short answers.

What is Causet?

A deterministic application runtime and compiler for stateful business workflows. Your app submits intents; Causet records state transitions and business events on a timeline you can inspect and replay.

Do I need to rewrite my app?

No. Causet sits beside your existing backend. Keep your frontend, database, APIs, and infrastructure. Start with one workflow.

Is Causet only for AI?

No. Causet is useful for any critical state transition. AI-agent decisions are one use case that needs durable state and auditability.

What can I run today?

See the capability table or the docs page What runs today? for availability, maturity, and production-use labels.

Is every replay path safe in production?

Not automatically. Read-only inspection and derived-state rebuilding do not repeat external effects. Decision replay and repair paths require explicit isolation, idempotency, and side-effect controls.

Where should a team start?

Run locally, explore the wallet demo, then follow the retrofit guide for one endpoint.