What is being compared
Temporal is a workflow engine that emphasizes deterministic replay in code. Cordum is a control plane that enforces a protocol contract (CAP) across gateways, schedulers, and workers. Both can coordinate long running work; they differ in where reliability decisions live.
Reliability models
Retry semantics
Temporal retries are typically configured in workflow code or activity options. Cordum surfaces explicit outcomes in the protocol: FAILED_RETRYABLE and FAILED_FATAL. That lets schedulers and orchestrators make deterministic decisions without parsing error strings.
The result is a consistent retry contract across languages and teams, even when workers are implemented in different stacks.
JobResult.status: JOB_STATUS_FAILED_RETRYABLE // transient error, safe to retry JOB_STATUS_FAILED_FATAL // fatal error, trigger rollback
Rollback and compensation
Temporal expects compensation to be encoded in workflow logic. Cordum uses a typed compensation template attached to the job request, so the orchestrator can dispatch inverse work without additional glue.
This is useful for small worker architectures where the worker is intentionally narrow and does not own rollback orchestration logic.
Observability and checkpoints
Temporal activities can emit heartbeats. Cordum pushes that capability down into the protocol withprogress_pct and last_memo so any worker can report checkpoints without custom tracing systems.
This makes long tasks visible to schedulers and operators, and provides a safe place to restart work after a crash.
Safety and approvals
Cordum introduces a Safety Kernel at the control plane level. Every job can be evaluated and constrained before execution. Temporal users typically implement similar checks in application code or external services.
The difference is not about capability - it is about where the enforcement lives: in code or in the control plane.
Tradeoffs and fit
- - Temporal is strong when you want workflow logic embedded directly in code with replay semantics.
- - Cordum is strong when you want protocol-level governance across heterogeneous workers.
- - Cordum favors small, specialized workers with explicit contracts and centralized policy.
- - Temporal favors SDK-centric orchestration with application-owned control flow.
When to choose which
Choose Temporal when you want a single-language workflow runtime and developer-owned orchestration logic. Choose Cordum when you need protocol-level governance, multi-language workers, and explicit control plane decisions for retries and rollback.