roadmap

Roadmap

This is an honest snapshot of where Causet is today and where it is going. Status labels are accurate as of the date this page was last updated.

The labels on this page (stable, in-progress, planned, proposed, available) describe engineering completion, feature by feature. They are a different axis from product availability, maturity, and production support — see What runs today? for the docs-facing readiness matrix that other pages link to.

Status labels:

  • stable — production-ready, used in production
  • in-progress — actively being built or improved
  • planned — committed to building; design complete or in progress
  • proposed — on the roadmap but not yet scheduled; design not started

Core Runtime

FeatureStatusNotes
Append-only event ledgerstablePostgreSQL-backed, per-entity cursor ordering
Declarative rules DSL (.causet)stableYAML-based, compiled to JSON IR
Compiler with error validationstablecauset-compiler, full cross-reference checking
Per-entity serial write orderingstableCursor-based optimistic locking
Entity snapshotsstableMaterializes current entity state from event history
Kafka fan-outstablecauset.ledger-events.v1, causet.projection-events.v1
SaaS multi-tenant layerstablePer-fork PostgreSQL schemas, release management
Preflight rulesstablereject op with typed error codes
Core rules (state mutations)stableset, add, sub, push, filter, remove, unset, merge
Event emissionstableemit, emit_each
Side effectsstablesubmit, schedule
Anonymous sessionsstableShort-lived JWTs for unauthenticated users

Projection Reliability

FeatureStatusNotes
Projection materialization (Kafka → PostgreSQL)stableR2DBC, reactive writes
Projection worker retry policystableConfigurable max retries + backoff
Projection failure capturestableprojection_failures table
DLQ routing on failureplannedRoute to causet.projection-dlq.v1 after max retries
Projection failure REST APIproposedREST endpoint for failure records (currently direct DB)
Deployment gates (causet projections doctor)plannedValidate projection health before release activation
Fixture-based regression testing for projectionsplannedDefine fixture events in DSL; verify on compile
Per-projection health endpointplannedEndpoint reporting per-projection lag + failure status

Workflow Durability (Sagas)

FeatureStatusNotes
Submit/schedule chains (side_effects)stableFan-out and delayed events across entities — see Workflows
sagas: DSL — entity state machinesstableCompiles to event-triggered core rules (op: merge) — no separate execution engine. See Defining Sagas
Saga failure paths (on_failure routing)proposedDeclarative failure routing beyond end: true terminal steps
External signals to sagasproposedWait for an external event before proceeding to next step
Long-running sleep (timer)proposedRequires integration with an external scheduler (e.g. EventBridge Scheduler)
Workflow observability dashboardplannedSaga state + step history in control plane UI

Replay Tooling

FeatureStatusNotes
causet recovery replay / causet recovery rewindavailableCLI-driven replay from a ledger cursor — see Recovery
Zero-downtime rebuild (parallel projection)proposedAutomated parallel projection + swap workflow
Time-travel queriesproposedQuery projection state at a specific past timestamp
Replay progress trackingplannedExpose replay ETA and progress via CLI/UI

Developer Experience

FeatureStatusNotes
causet build compile CLIavailableBundled in causet CLI — see Install
causet doctor CLIavailableLocal diagnostic checks — see causet doctor
causet dev (compile + watch loop)availableSee causet dev
Local dev mode against self-hosted stackin-progressDocker Compose stack for team contributors — see Development Setup
Monaco editor with DSL schemain-progressControl plane UI — DSL schema for autocomplete
DSL language server protocolproposedIDE integrations for VSCode, IntelliJ

CLI Completeness

For the authoritative, currently-shipped command set, see the CLI table in Install Causet and the commands used throughout Deployments.

CommandStatus
causet build compile / causet build validateavailable
causet doctoravailable
causet devavailable
causet loginavailable
causet deployavailable
causet fork create / list / diff / deleteavailable
causet intent / causet queryavailable
causet inspect entity / causet inspect timelineavailable
causet recovery replay / causet recovery rewindavailable
causet projections list / doctor / replayproposed
causet projections failures list / retryproposed
causet migrations apply / statusproposed
causet events publishproposed
causet dlq list / retryproposed

Cloud Deployment

FeatureStatusNotes
ECS deploymentstableUsed in production (Causet Cloud)
Docker Compose (self-hosted local stack)team contributorsPrivate source — Docker build and publish workflow — see Installation
Terraform modulesin-progressECS + RDS + MSK + ElastiCache
Kubernetes Helm chartproposedNot yet designed
AWS CDK constructsproposedNot yet scheduled

Admin UI / Dashboard

FeatureStatusNotes
Control plane UIstableRelease management, fork management
Entity browserstablegRPC browser exists; web UI in progress
Projection health dashboardplannedPer-projection lag, failure count, last event
DLQ management UIproposedList, inspect, retry DLQ messages
Replay UIproposedTrigger replay from control plane
Event log viewerstableBrowse ledger events per entity in UI

SDK and Client Libraries

Official SDKs live at github.com/Causet-Inc/causet-sdks. Typed clients for TypeScript, Python, Go, Java, and Laravel/PHP — intents, named queries, SSE intent progress, entity state caching, and real-time WebSocket/SSE patches. All are at 0.1.0 with test coverage; registry publishing is in progress for languages outside the JavaScript / TypeScript tier. Docs: SDKs.

Per-language availability, maturity, and production support are tracked at What runs today? — not duplicated here.

FeatureStatusNotes
REST APIstableStable integration surface
WebSocket real-time gatewayavailableConsumed by every SDK’s connectStream()
Source repo (causet-sdks)availablegithub.com/Causet-Inc/causet-sdks
@causet/sdk-core / @causet/sdk / @causet/sdk-node / @causet/sdk-nextavailableShared TS implementation — browser, Node.js 18+, Next.js
causet-sdk (Python)in-progressAsync + sync clients
causet/laravel-sdkin-progressLaravel Facade + DI
causet-sdk-goin-progressGo 1.22+
com.causet:causet-sdkin-progressJava 17+ (0.1.0-SNAPSHOT)
npm / PyPI / Packagist / Maven publishin-progressIn progress

Usage examples

Every SDK shares the same shape: construct a client from apiUrl + platformSlug + appSlug + apiKey (or a bearer JWT), submitIntent() an intent, runQuery() a named projection, and optionally connectStream() for real-time patches.

TypeScript — @causet/sdk (browser) or @causet/sdk-node (backend)

import { CausetClient } from '@causet/sdk'; // or '@causet/sdk-node'
 
const client = new CausetClient({
  apiUrl: 'https://api.causet.cloud',
  platformSlug: 'my-platform',
  appSlug: 'my-app',
  apiKey: process.env.CAUSET_API_KEY,
});
await client.init();
 
const result = await client.submitIntent('ticket_stream', 'tkt_1', 'CREATE_TICKET', {
  customer_id: 'cust_1',
  subject: 'Help',
});
 
const rows = await client.runQuery('open_tickets', { status: 'open' }, { limit: 20 });
 
await client.connectStream('ticket_stream', { channels: [{ channel: 'ledger' }, { channel: 'state' }] });
client.on('patch_op', (ev) => console.log(ev.ops));
 
client.destroy();

Next.js — @causet/sdk-next

'use client';
import { useCausetQuery, useCausetSubmitIntent } from '@causet/sdk-next';
 
function TicketList() {
  const { data, loading, refresh } = useCausetQuery('open_tickets', { status: 'open' }, { limit: 20 });
  const { submitIntent, pending } = useCausetSubmitIntent();
 
  return (
    <ul>
      {data?.items.map((row) => <li key={String(row.id)}>{String(row.subject)}</li>)}
      <button disabled={pending} onClick={() => submitIntent('ticket_stream', 'tkt_1', 'CLOSE_TICKET', {}).then(refresh)}>
        Close first ticket
      </button>
    </ul>
  );
}

Python — causet-sdk

from causet_sdk import CausetClient
 
client = CausetClient(
    api_url="https://api.causet.cloud",
    platform_slug="my-platform",
    app_slug="my-app",
    api_key="ck_live_xxx.secret",
)
await client.init()
 
result = await client.submit_intent("ticket_stream", "tkt_1", "CREATE_TICKET", {
    "customer_id": "cust_1", "subject": "Help",
})
rows = await client.run_query("open_tickets", {"status": "open"}, limit=20)
await client.connect_stream("ticket_stream")
client.destroy()

PHP / Laravel — causet/laravel-sdk

use Causet\Laravel\Facades\Causet;
 
Causet::init();
 
$result = Causet::submitIntent('ticket_stream', 'tkt_1', 'CREATE_TICKET', [
    'customer_id' => 'cust_1',
    'subject' => 'Billing question',
]);
 
$rows = Causet::runQuery('open_tickets', ['status' => 'open'], limit: 20);

Go — causet-sdk-go

client := causet.NewClient(causet.Config{
    APIURL: "https://api.causet.cloud",
    PlatformSlug: "my-platform",
    AppSlug: "my-app",
    APIKey: os.Getenv("CAUSET_API_KEY"),
})
result, _ := client.SubmitIntent("ticket_stream", "tkt_1", "CREATE_TICKET", map[string]any{"subject": "Help"})
rows, _ := client.RunQuery("open_tickets", map[string]any{"status": "open"}, causet.QueryOptions{Limit: 20})
client.ConnectStream(ctx, "ticket_stream", causet.StreamConnectOptions{}, onEvent)
client.On("patch_op", func(ev any) { fmt.Println(ev) })

Java — com.causet:causet-sdk

CausetConfig cfg = new CausetConfig();
cfg.apiUrl = "https://api.causet.cloud";
cfg.platformSlug = "my-platform";
cfg.appSlug = "my-app";
cfg.apiKey = System.getenv("CAUSET_API_KEY");
CausetClient client = new CausetClient(cfg);
 
JsonNode result = client.submitIntent("ticket_stream", "tkt_1", "CREATE_TICKET", Map.of("subject", "Help"));
JsonNode rows = client.runQuery("open_tickets", Map.of("status", "open"), opts);
client.connectStream("ticket_stream", null, event -> System.out.println(event));

Full API reference, configuration options, and error handling for each SDK: SDK Overview.


Scaling and Performance

FeatureStatusNotes
Horizontal projection worker scalingstableKafka partition-bounded
Query service horizontal scalingstableStateless, ALB-backed
Redis query result cachingstableTTL-based
Per-tenant Kafka topicsproposedCurrently all tenants share the same topics
Shard routing for queriesproposedRoute query requests based on tenant to dedicated DB replicas
Connection pooling improvementsplannedPgBouncer or RDS Proxy integration

AI Memory Layer

FeatureStatusNotes
op: decision — declarative LLM calls in side_effectsavailableAI
Vector memory — event ingestion + retrievalavailableVector Memory
Providers, prompts, BYOKavailableProviders & Prompts
Support Copilot exampleavailableExample walkthrough
Application memory (deterministic entity state)availableApplication Memory

Open Source

Causet today is Managed Causet Cloud (managed control plane, controlled early access / waitlist) plus a locally-run causet CLI and Docker stack. A fully self-managed runtime and compiler source release is planned — see the coming-soon tier at What runs today?. Public SDK and template repositories are Apache 2.0 today.

FeatureStatusNotes
Managed Causet Cloud (managed control plane)availableControlled early access for customer sign-up — Sign up
causet CLI (install script)availablecurl -fsSL https://install.causet.io/install.sh | bash — see CLI
Public documentation sitein-progressThis site
Local Docker runtimeavailablecauset local up — see CLI
Open-source, self-managed runtime and CLI distributionproposedPlanned; see What runs today?
Homebrew tapplannedAfter native binary distribution ships
npm / PyPI / Packagist SDKsin-progress@causet/sdk, causet-sdk, causet/laravel-sdk — see SDKs
Public changelogplannedVersioned, linked from docs
Outbound HTTP webhook deliveryavailableManaged HTTP callbacks from Causet to your app