Roadmap

Where Trax is headed

Ahead

Building now

One operations console

One dashboard, organised by trains, machines and schedules
An overview that starts with what needs attention
A picture of every state machine
Works where persisted operations are required

Building now

The Trax book

One shop, built from an empty folder to a deployed app
One Trax feature a chapter, in the order you need them
Every chapter compiles as the project so far

Building now

Deploy with one command

A template to a running HTTPS app on AWS with one command
A compose stack for any other server from the same app
Migrations, secrets and sign-in set up as part of the deploy
The app's own startup checks stop an unsafe deploy

Sketch, not final

$ trax deploy plan --env production
$ trax deploy --env production
$ trax deploy --target compose

Later

From a spec to a running app

An OpenAPI or GraphQL spec in, a running API out
Auth from the shipped packages, closed by default
Postgres or SQLite tables and migrations
Working create, read, update and delete
Re-running after a spec change keeps your code

Sketch, not final

$ trax generate --schema ./shop-api.yaml \
    --auth jwt --database postgres \
    --tables Product,Order --output ./Shop

Later

One app, end to end

A full app built only with the CLI
A tested guide from a spec to that app

Shipped

October 2026 · 1.67

Fetch only what a page needs

Write the query a page needs as a .graphql file
A typed function for each one, with exactly the fields it asks for
The server registers them when it starts, and checks them there
Answers that refer back to themselves no longer stop a server

Code

query OrderCard($input: FindOrderInput!) {
  discover {
    findOrder(input: $input) { title customer { name } }
  }
}

$ trax client --manifest web/src/trax/manifest.json --out web/src/trax \
    --documents 'web/src/**/*.graphql'

October 2026 · 1.65

Child machines

A state starts a child machine and waits for it to end
The child's outcome moves the parent on
Leaving the state removes the child

Code

m.In(OrderState.Packing)
    .Spawns<ParcelMachine, OrderContext, ParcelResult>(c => c.ParcelId)
    .OnDone(OrderState.Sent)
    .OnFailed(OrderState.Lost)
    .OnCancelled(OrderState.Recalled);

October 2026 · 1.64

Generated clients

A React client generated by the CLI
A typed function for each operation
The machines, running in the browser
Live progress while a train runs
Operation hashes on the wire, never query text

Code

$ trax client --target react --manifest web/src/trax/manifest.json --out web/src/trax

configureTrax({ url, socketUrl, user });
const checkout = useRememberedCheckout();
checkout.send("Submit", { address });

October 2026 · 1.63

Machines become the API

A typed mutation for each machine event
Authorization on each event, checked on the server
Persisted operations only
Live snapshots over a subscription

Code

mutation {
  machines {
    checkout {
      submit(id: $id, input: { address: $address }, requestId: $req) {
        state
        context { total }
      }
    }
  }
}

subscription {
  machineChanged(machine: "checkout", id: $id) { state revision }
}

October 2026 · 1.62

Composition

Parallel branches in one run
A machine state that runs a train
Checkpoints, and resuming from any step
Every branch and step visible in GraphQL and the dashboard

Code

 Chain<LoadCorpus>()
.Parallel(p => p
    .Branch("embedding", b => b.Chain<EmbeddingSimilarity>())
    .Branch("cocitation", b => b.Chain<CoCitationOverlap>()))
.Chain<CombineSignals>()
.Resolve();

 m.In(Partition.Ingesting)
.Invokes<IIngestPartitionTrain, IngestInput, IngestOutput>(ctx => new IngestInput(ctx["source"]!.GetValue<string>()))
.OnDone(Partition.Ingested)
.OnFailed(Partition.Failed)
.OnCancelled(Partition.Cancelled);

October 2026 · 1.60

Recorded decisions, and one repository

The decisions a run makes are recorded
Requeues and retries replay them
A step-by-step timeline on every run
Every dashboard action also in GraphQL
One repository, one version for every package

September 2026 · 1.57

Hardening

Owner-scoped queries, checked at startup
Sensitive values masked in stored inputs and outputs
Signed requests between the scheduler and its runners
Retention set per train
Architecture decision records, and the docs served as llms.txt

July to September 2026 · 1.52

State machines

Machines written in C#, with a TypeScript twin
Declarative rules exported as one portable description
The twin generated from it by the CLI
Both runtimes checked against each other on a shared corpus
A runtime self check at startup

June 2026 · 1.41

Guards

Test packages that fail the build when the architecture drifts
Every GraphQL surface must say who may call it
A hook that runs when a train is queued

May 2026 · 1.38

Persisted operations

Asynchronous chains end to end
Persisted GraphQL operations, managed from the dashboard
One operations service behind the dashboard and GraphQL
Cognito, and several JWT schemes at once
Live updates over SignalR
A typed .NET GraphQL client

April 2026 · 1.32

SQLite and authentication

A SQLite data provider
API keys, JWT and OIDC
An audit trail of API calls
The caller passed to the steps of a train

March 2026 · 1.30

Scheduling

Six-field cron, misfire policies and jitter
Delayed one-off jobs and calendar exclusion windows
Cancellation and run timeouts
Per-train and global concurrency limits
Dead letters, requeue and retry backoff

March 2026 · 1.28

Workers anywhere

Runs handed to remote HTTP workers
Jobs submitted through SQS and run on AWS Lambda
Dispatch retried with backoff, and requeued when it fails
Runs left behind by a dead worker are reaped

March 2026 · 1.27

A GraphQL API for trains

A typed mutation for each train, to run it or queue it
Lifecycle events as subscriptions
Entity queries with filtering, sorting and paging
Authorization on each train
One AddTrax builder, checked at startup

March 2026 · 1.24

The CLI

A new project from a template
Trains generated from an OpenAPI or GraphQL schema

February 2026 · 1.0

Trains, and the first packages on NuGet

Trains: typed chains of small steps
Every run recorded, in Postgres or in memory
A mediator that runs a train from its input type
A scheduler, an operations dashboard and project templates
Analyzers and a Rider plugin that check a chain as you write it