General-purpose workflow engine
Workflows you can read,
version, and patch
while they run.
Tickr schedules and orchestrates any program — Python next to Go next to a shell script — each task a reproducible, hermetic build. No SDK in your code.
Any task · Any language · No SDK
Open-source data plane · Managed control plane · Run it on your compute or ours.
Workflows are typed configuration.
Author a workflow declaratively, in a typed DSL — tasks, edges, gates, loops. You state the graph; Tickr owns running it. Contracts validate the whole definition at registration — a malformed workflow is rejected before it ever runs, not discovered at 3am. The definition is data: read it, diff it, review it in a PR.
01
# draft, refine, publish, reject: mkTask (defined above)
02
let decision =
03
mkRoutingVar { name = "decision", type = "string" } in
04
let review = mkTask {
05
name = "review", args = [],
06
nix_expression_path = "review.nix",
07
routing_vars = [ decision ],
08
} in
09
mkWorkflow {
10
slug = "release-review", name = "release-review", args = [],
11
tasks = [
12
# a ring of tasks, iterated — not unrolled
13
mkLoop { name = "review-loop",
14
tasks = [ draft, refine ], exitTo = review },
15
mkTaskGroup {
16
name = "route", args = [],
17
tasks = [ review, publish, reject ],
18
edges = [
19
mkEdge { from = review, to = publish, kind = "data",
20
gate = mkPredicateGate { routing_var = decision,
21
op = "Eq", value = "approve" } },
22
],
23
},
24
],
25
}
Anatomy of a workflow.
One workflow, drawn whole — the way the Console draws it. Walk it.
Start it every way.
Cron schedules, external signals over HTTP or the queue, a manual fire-now, or a wakeup from another workflow. All of it lands on one timer wheel.
Cycles are legal here.
Loops are first-class: a ring of tasks that iterates until its exit condition. The ring turning is “continue”; the one arrow that leaves is the one real decision. Drawn as an actual ring — not unrolled into a lie.
Hold an edge until the world is ready.
Signal gates park a workflow mid-graph until an external event matching a predicate arrives — with expiry for the case where it never does. The payload it captures flows into downstream tasks’ context.
Route on what the run produces.
A task produces a routing variable at runtime; downstream edges each carry a predicate over it. The edge whose predicate holds fires; the other stays parked. Branching is data.
PLATE II — ANATOMY OF A WORKFLOW · AS THE CONSOLE DRAWS IT
Every card you just walked is a Nix build — hermetic, pinned, the same run every time. Any language. No SDK.
Reproducible by construction.
Change a workflow while it’s running.
A running instance is a graph, and the graph can grow mid-flight. The patcher can be anyone with context: a task already in the graph, deciding from the variables the run has produced — or an external caller. Patches are typed constructors, validated like any workflow, applied atomically.
let patch = mkChain { anchor = "L4", # plan's graph code steps = [ { handle = "search", task = search }, { handle = "synthesize", task = synthesize }, { handle = "report", task = report }, ],}Flip the control.
Sometimes the work isn’t Tickr’s to run. An agent explores, decides, acts — and Tickr keeps the ledger: every external step lands in the workflow as a shadow task, the record of something that already happened. A ledger records; it doesn’t replay. And when the durable tail shows up — the warehouse job, the long batch, the send — the agent hands it to Tickr with a patch, and Tickr runs it with retries and receipts. One workflow, one record — no matter how many drivers.
An open integration format.
A Tickr task is a plain program. It reads inputs and publishes outputs
through one binary — tickr-ctx get table_name —
one line of shell from any language. That is what
truly language-agnostic means: no bindings, no base
class, no skeleton to follow — any program that runs is a valid
integration. And the format is open — the contract is the
envelope shape and the key-value semantics, with no platform API to
fall behind — so an integration outlives any single runtime,
including ours.
subprocess.run(["tickr-ctx", "get", "table_name"]) exec.Command("tickr-ctx", "get", "region").Output() report_url=$(tickr-ctx get report_url --wait 30s) Every integration brings its own DSL.
The Kubernetes integration ships with its authoring surface:
mkK8sJob. One call expands into the whole task group
— submit, monitor, clean up, outputs wired. An integration hands
you a rich, typed vocabulary — functions with
contracts, validated at registration; a typo is caught before anything
runs. And it composes: mkK8sJob sits next to
mkTask, inside a loop, behind a gate. The tool underneath
can be anything that runs — even a CLI you already trust —
packaged with Nix and wired by the constructor.
mkK8sJob without writing any Nix — an integration brings its own build.Open at the edges. Managed at the core.
The Tickr data plane — conductor, executor, CLI, and the Console — is open source. It’s the part that touches your code, your data, and your compute, so you can read every line of it. It pairs with the Tickr control plane — the managed scheduling core that gives it a brain: triggers, state, versions, patches, control-flip. Your data and execution never leave the data plane — only the metadata the control plane needs to drive those controls ever crosses to it. Run the data plane wherever you want; every deployment pairs it with a control plane.
- Cloud
Data plane and control plane on our infrastructure. Zero ops.
- BYOC
Your compute, our management. We install and operate the data plane inside your network; your data and execution never leave it.
- Self-hosted data plane
Run the open-source data plane yourself, connected to the managed control plane.
General-purpose means general.
The same graph runs your data loads, your release trains, and your agents’ errands.
-
Nightly warehouse loads
Retried, hermetic, on the tick.
-
Release trains
Build → gate on approval → promote.
-
Looping agents
critique ▸ revise rings that run until they’re done.
-
Approval chains
Signal gates that happily wait three days.
-
Agent-delegated jobs
The durable tail of an agent’s plan.
-
Backfills & migrations
Long, idempotent, resumable.
Four tiers. One control plane.
-
Free
Free
Try Tickr.
Free control plane. Bring your own data plane.
Get started - recommended
Cloud
TBD todo
Managed, end to end.
Control plane and data plane on our infrastructure.
Get started -
BYOC
Contact us
Your compute, our management.
We install and operate the data plane inside your network.
Contact us -
Enterprise
Contact us
BYOC, plus the controls.
SSO, audit, support SLAs, and custom quotas.
Contact us
See full pricing → Every plan includes the control plane. Prices are placeholders pending launch.
Start building with Tickr.
Author it as config, run it reproducibly, and patch it live.