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.

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

The causet-sdks packages ship typed clients for TypeScript, Python, Go, Java, and Laravel/PHP — intents, named queries, SSE intent progress, entity state caching, and real-time WebSocket patches. All are at 0.1.0 with 100% test coverage; publishing to npm/PyPI/Packagist is in progress. Full usage docs: SDK Overview.

FeatureStatusNotes
REST APIstableStable integration surface
WebSocket real-time gateway (ws-gateway-go)availableHello/sub protocol at /ws — ledger + state patch channels, consumed by every SDK’s connectStream()
@causet/sdk-core (TypeScript core client)available (pre-release)Intents, queries, SSE streaming, WebSocket, entity-state cache. Not yet published to npm
@causet/sdk (browser/ESM)available (pre-release)Re-exports sdk-core for bundler/browser apps
@causet/sdk-node (Node.js 18+)available (pre-release)createCausetClient() factory for backend services
@causet/sdk-next (Next.js / React)available (pre-release)CausetProvider + hooks (useCausetQuery, useCausetIntent, useCausetEntity) and server helpers
causet-sdk (Python 3.10+)available (pre-release)Async (CausetClient) and sync (CausetClientSync); not yet published to PyPI
causet/laravel-sdk (PHP / Laravel 11+)available (pre-release)Facade + DI, intent SSE, connectStream() for live ledger/projection SSE; no WebSocket client (synchronous Guzzle)
causet-sdk-go (Go 1.22+)available (pre-release)Intents (sync + SSE progress), queries, projections, entity listing, entity-state cache, WebSocket + SSE stream transport
com.causet:causet-sdk (Java 17+)available (pre-release)Intents (sync + SSE progress), queries, projections, entity listing, entity-state cache, WebSocket + SSE stream transport

Usage examples

Every SDK shares the same shape: construct a client from apiUrl + platformSlug + appSlug + apiKey (or a bearer JWT), emit() 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.emit('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, useCausetIntent } from '@causet/sdk-next';
 
function TicketList() {
  const { data, loading, refresh } = useCausetQuery('open_tickets', { status: 'open' }, { limit: 20 });
  const { emit, pending } = useCausetIntent();
 
  return (
    <ul>
      {data?.items.map((row) => <li key={String(row.id)}>{String(row.subject)}</li>)}
      <button disabled={pending} onClick={() => emit('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.emit("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::emit('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.Emit("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.emit("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 Causet Cloud (managed control plane, Early access / waitlist). The causet CLI is publicly distributed via Causet-Inc/causet-cli releases.

For the docs-facing readiness table (labels used across the site), see What runs today?.

FeatureStatusNotes
Causet Cloud (managed control plane)Early accessSign up
causet CLI (install script)Available nowcurl -fsSL https://raw.githubusercontent.com/Causet-Inc/causet-cli/main/install.sh | sh — see Install
Public documentation sitein-progressThis site
Self-hosted Docker stackComing soon (public) / team contributors todayPrivate source — see Development Setup
Homebrew tapplannedAfter native binary distribution ships
npm / PyPI / Packagist SDKsPreview@causet/sdk, causet-sdk, causet/laravel-sdk — see SDKs
Public changelogplannedVersioned, linked from docs
Outbound HTTP webhook deliveryAvailable nowManaged HTTP callbacks from Causet to your app