Explanation

Trax compared with Temporal and Durable Functions

Checked on 2026-11-05 against the Temporal and Microsoft Learn docs. Corrections are welcome as issues.

Temporal is a durable execution platform: a server cluster, or Temporal Cloud, that your workers connect to. Workflow code is replayed against a recorded event history, so it has to be deterministic, and side effects go in activities that are retried by default. Durable Functions is the same idea as an Azure Functions extension, and the Durable Task SDKs are its self-hosted form, backed by the Azure Durable Task Scheduler.

Trax works differently. It does not replay your code. A train is ordinary .NET code that runs from the top, or from the last checkpoint it declared, and every run is recorded as a row in your own database. Anything that has to wait for days, or for a person, is a state machine whose state is stored between events.

What you run

TraxTemporalDurable Functions and the Durable Task SDKs
What you operatePackages in your ASP.NET Core app, and a databaseA Temporal server cluster or Temporal Cloud, and your workersAn Azure Functions app, or your app and the Durable Task Scheduler
StoragePostgreSQL; SQLite for a single process; in-memory for testsCassandra, PostgreSQL or MySQL; SQLite for developmentDurable Task Scheduler (recommended), Azure Storage, MSSQL, Netherite (ends 2028); the SDKs use the Durable Task Scheduler only
Off Azure, or air-gappedYesYes, self-hostedDurable Functions on MSSQL only
LanguagesC#; machines also run in TypeScriptGo, Java, Python, TypeScript, .NET, Ruby, PHP and more.NET, JavaScript and TypeScript, Python, Java, PowerShell
.NET.NET 10 only.NET 6 and laterThe isolated worker model (in-process support ends 2026-11-10)
LicenceMITMIT; Temporal Cloud is paidSDK MIT; the Durable Task Scheduler is a paid Azure service

How work survives a crash

TraxTemporalDurable Functions
ModelEach run recorded; a train can declare Checkpoint<TState>(), and a resumed run skips to itEvent history and deterministic replayEvent sourcing and replay
Rules on your codeNone for trainsStrict: Workflow.UtcNow, Workflow.DelayAsync, no Task.RunStrict: CurrentUtcDateTime, NewGuid(), no I/O in orchestrators
Unit of side-effecting workA junction in a trainAn activityAn activity
RetriesThe whole run, for scheduled work: 3 retries by default, 5 minutes doubling to 1 hour, then a dead letter. A run queued on demand is not retriedPer activity: unlimited attempts by default, 1 second doubling to 100 secondsPer activity or sub-orchestration, when you set a retry policy
After the last retryA dead letter, requeued from the operations console, GraphQL or a terminal; the requeue replays the original's recorded decisionsRetries until a timeout or a non-retryable errorThe orchestration stays Failed; rewind is in preview
Repeated side effectsA rerun repeats junctions after the checkpoint. IdempotentEffect and RunsOnce record a result once and pass the same key on a repeatActivities may run more than once; make them idempotentActivities run at least once; make them idempotent
Resume a failed run part wayResume, or resume from a chosen checkpoint, from the console or GraphQLReset: a new execution from a chosen point in the historyRestart from the start in the dashboard; rewind is in preview
Parallel workParallel: a fixed set of named branches, each in its own scope; one failure cancels the rest by defaultWorkflow.WhenAllAsync over any number of activities, up to 2,000 pendingFan-out and fan-in over any number of activities
Cancel a running runFrom the console, GraphQL or code; it stops at its next junction on any host and is recorded CancelledCancel (an activity sees it only if it heartbeats), or terminateTerminate, suspend, resume

A run's timeline: it starts, PriceCart and ReserveStock finish, a checkpoint is saved, the process crashes, and the run resumes from the checkpoint instead of starting over, then finishes.

Temporal and Durable Functions make every await in a workflow durable. Trax makes the points you declare durable: checkpoints in a train, and states in a machine. Junctions between a checkpoint and a crash run again, so make the ones that call other systems safe to repeat.

Concurrency

TraxTemporalDurable Functions
One run at a time per recordQueued runs with the same subject key run one after another; the rest wait in the queueOne open execution per workflow id; a second start fails or returns the open oneA singleton orchestration: check the instance id, then start (Microsoft documents a race)
Caps on concurrent runsPer train, per caller and global caps for direct runs; global and per-group caps for queued workSlot suppliers per workerPer-worker settings for activities and orchestrators

Decisions and models

TraxTemporalDurable Functions
A model in the flowA Switch, Gate or Scale step asks a typed question that a decider answers: a rule, a lookup or a model. Every track is declared and checked at startupAn OpenAI Agents SDK integration (Python): the agent loop runs in a workflow and model calls run as activitiesA Durable Task extension for Microsoft Agent Framework: durable agent sessions
A retry and the modelA retry or requeue replays the recorded answers, within 24 hours by default; "ask afresh" skips the replayCompleted activities are not repeated during replayCompleted agent calls are not rerun on recovery
Try a new model beside the live oneShadow deciders answer alongside the live one, and each answer is recorded with whether it agreedNot foundNot found
Docs for coding agentsAgent skills published with each release, and llms.txtllms.txtNot found

Waiting, and input from outside

TraxTemporalDurable Functions
Long waitsA machine state, not a trainIn workflow codeIn orchestrator code
Durable timersA machine state's After(...), fired by the server, up to 366 daysWorkflow.DelayAsyncCreateTimer
Input to a running flowA machine event, served as a typed GraphQL mutation. A running train takes no inputSignals and updatesWaitForExternalEvent
Reading live stateA machine's get query and change subscription; GraphQL subscriptions for a train's state changes and junction eventsQueriesCustom status and the instance status API
ChildrenA state invokes a train or spawns a child machine; leaving the state cancels itChild workflowsSub-orchestrations
New code under running instancesA machine's Version and MigrateFrom migrate stored snapshots forward; a checkpoint refuses a resume if the chain changedWorker Versioning or patchingOrchestration versioning, side by side, or stop and restart

Scheduling

Trax's scheduler is a large part of what it is for: recurring and one-off runs of trains, schedules that depend on each other, caps and priorities across groups of them, and retries that end in a dead letter an operator can requeue. Temporal has Schedules. Azure has the Functions timer trigger, eternal orchestrations, and interval schedules in the Durable Task Scheduler's .NET SDK.

TraxTemporal SchedulesDurable Functions and the Durable Task Scheduler
What can be scheduledCron with 5 or 6 fields, intervals (Every.*), a one-off after a delay, or a run that follows anotherIntervals with an offset, calendar expressions, cron; several in one scheduleTimer: NCRONTAB cron. Durable Task Scheduler: an interval only. Eternal orchestration: your own timer
Time zoneUTC onlyUTC by default; another zone can be namedUTC by default; WEBSITE_TIME_ZONE on Windows and Linux Premium or Dedicated
JitterVariance(...)JitterNot found
ExclusionsDays of the week, dates, date ranges, daily time windowsCalendar expressions can leave times outNot found
OverlapA schedule never overlaps itself: it is skipped while a run is queued or runningSix policies: skip, buffer one, buffer all, cancel other, terminate other, allow allTimer: one instance, no new trigger while one runs. Eternal: never overlaps
Missed runsFireOnceNow or DoNothing, past a threshold, per scheduleA catchup windowTimer: IsPastDue on a late run. Durable Task Scheduler: StartImmediatelyIfLate
Start, end and run limitsNoStart and end time, a limited number of runsDurable Task Scheduler: start and end time
BackfillNoYesNo
Pause and editEnable and disable a schedule or a whole group; edit its cron, interval, priority, retries and timeout from code or the consolePause with a note, pause on failure, updateDurable Task Scheduler: pause, resume, update. Timer: redeploy or change an app setting
Run nowTrigger a schedule now or after a delay, or a whole groupTriggerTimer: a manual HTTP call
Schedules that depend on schedulesYes: a child runs after its parent succeeds, cycles are refused at startup, and a parent can decide at runtime which dormant children run and with what inputNot documented: a schedule is independent of other workflowsNo
Many at onceScheduleManyAsync, IncludeManyNot foundNot found
Concurrency capsA global cap, and a cap per group of schedules (approximate with several hosts)Per worker and per task queue; no cap per group of schedulesNot covered here
Priority0 to 31 per schedule or group; dependents get a boostTask queue priority 1 to 5, and fairness keysNot found
One at a time per recordQueued runs that share a subject key run one after anotherNot covered hereA singleton orchestration with a fixed id
When a scheduled run failsRetried with backoff, resumed from its last checkpoint, then a dead letter for an operatorNo retry unless the workflow sets a retry policy; optional pause on failureTimer: no retry unless you add a retry policy. Eternal: ends as Failed and does not restart
Where it runsThe host, or remote workers over HTTP, SQS or AWS LambdaWorkers polling task queuesFunctions scale-out; Durable Task Scheduler workers
From the UIThe operations console: trigger, enable, disable, cancel, edit, requeue dead lettersWeb UI and CLIThe Azure portal; the Durable Task Scheduler dashboard

Temporal's Schedules are the more flexible clock: time zones, overlap policies, backfill and run limits. Trax's scheduler is the more complete job system: schedules that depend on each other, caps and priorities across groups, dead letters, and an operations console built around them.

State machines and clients

TraxTemporalDurable Functions
State machineDeclared states, events, guards, timers, invoked trains and child machinesNone built in: a workflow with signalsEntities: keyed state, one operation at a time, no declared transitions
A browser drives itYes: a typed API per machine; the browser predicts with the same machine, and the server applies the moveThrough a backend you writeThrough a function you write; the built-in HTTP API needs a system key that must not reach the client
Who may send an eventDeclared per event, checked by the server; a served machine with an undeclared rule refuses to startThe Write permission on a namespace covers signalling any workflow; finer rules need a custom authorizerA function key or system key; Durable Task Scheduler roles per scheduler or task hub
Who may start a run[TraxAuthorize] or [TraxAllowAnonymous] on each served train; a served train with neither stops the hostThe Write permission on a namespaceA function key, or the trigger's authorization level
Typed clientstrax client writes typed TypeScript or C# clients from the operations the app sends; .NET apps drive machines through Trax.StateMachine.ClientNot foundNot found

Observability

TraxTemporalDurable Functions
UIThe operations console: runs, dead letters, schedules, machines. Cancel, requeue (replaying or re-asking decisions), resume from a checkpoint, and bulk actions over a filterWeb UI: event history, signal, reset, terminateDurable Task Scheduler dashboard, the Azure portal
From a terminal or a scripttrax-console, with a JSON lines mode for scripts and agentsThe temporal CLI, with JSON outputNot found
HistoryEach run's input, output, timing, failure and steps; each decision with its decider; log lines tied to the run; a machine's transitions with who made themEvery event of every executionEvery history event, purgeable
Pushed eventsLifecycle hooks, GraphQL subscriptions, SignalR to browsers, RabbitMQ between processesNot foundLifecycle events to Event Grid
Sensitive dataMembers marked [TraxSensitive] are masked when inputs and outputs are storedA payload codec encrypts payloads before they reach the serviceNot found
TracingNo OpenTelemetry spans for runs; a span per Parallel branch, and meters for machines, audit, persisted operations and change signals, through System.DiagnosticsAn OpenTelemetry extension, and metricsDistributed tracing through Application Insights
Size limitsNo cap on a run's history; caller input 256 KiB, a checkpoint 1 MiB, a machine snapshot 64 KiB by default51,200 events or 50 MB per execution1 MB payloads on the Durable Task Scheduler

Developer experience

TraxTemporalDurable Functions
Caught before the first runThe host refuses to start when a chain can never run or a served train has no authorization ruleA replayer runs recorded histories against new code to find non-determinismSome violations throw at run time; Microsoft says not to rely on it
TestingA junction is a plain class; a train runs on the in-memory provider; the whole host runs under WebApplicationFactory; architecture-guard packages. No test clock for machine timersA time-skipping test environment, an activity environment, a replayerA mocked orchestration context; an in-memory test host in the SDKs
Start a projectdotnet new trax-api, trax-scheduler or trax-hub, each with a test projecttemporal server start-dev and an SDKfunc init and func new

When to choose Temporal

  • Workflows run for months, or have thousands of steps, and you want every await durable rather than the points you declare.
  • You need per-activity retries, heartbeats and timeouts. Trax retries the whole run.
  • Workflows span languages, or teams in different languages call each other's workflows.
  • You want the complete event history of every execution to debug from.
  • Schedules need time zones, overlap policies or backfill.
  • You can run a Temporal cluster or pay for Temporal Cloud, and you accept the determinism rules.
  • You are on .NET 6 to 9.

When to choose Durable Functions

  • You are on Azure already and want serverless orchestration that scales to zero, with Functions triggers and bindings.
  • You want Application Insights tracing and Azure role-based access with no extra setup.
  • Your database is SQL Server. Trax has no SQL Server provider.

When to choose Trax

  • People drive the process through a browser or an API, and the server has to decide, per event, who may do what.
  • You want the page to know the next valid moves from the same machine the server runs.
  • You schedule a lot of work: hundreds of schedules in groups with their own caps and priorities, schedules that wait on each other, and failures that end in a dead letter an operator requeues from the console.
  • A rule or a model chooses the branch, every branch is checked at startup, and a retry reuses the recorded answer instead of asking the model again.
  • Operators resume, cancel or requeue failed runs from a browser or a terminal, with no separate service to run.
  • You want plain .NET code with no determinism rules, every run recorded in your own Postgres, and no cluster or cloud service to run beside your app.