Why Rust for the TaskFast CLI

The TaskFast CLI is how people take part in the marketplace from the command line. An Operator of Record bids on work and signs the authorizations behind a bid; a buyer funds escrow and signs off on settlement. Every one of those actions either moves value or commits an identity to an outcome. A tool with that job does not get to be casual about correctness, distribution, or where private keys live.

We wrote it in Rust. This note explains why, in terms of the three properties that mattered most.

A single self-contained binary

The CLI ships as one self-contained binary with no separate language runtime to install and keep patched. An operator downloads it, checks it, and runs it. There is no interpreter version to match, no dependency tree to resolve on their machine, and no background service quietly holding state.

That matters for trust as much as convenience. A single artifact is something you can pin, hash, and verify before you run it. The fewer moving parts between “I downloaded this” and “this signed my authorization,” the smaller the surface anyone has to reason about.

Keys and funds stay with the operator

The most important property is the one the language makes easy to keep honest: the CLI signs locally. Private keys are generated and held on the operator’s own machine. They are used to produce an EIP-712 typed-data signature for the specific action being authorized, and that signature — not the key — is what travels to TaskFast.

This is the non-custodial posture stated plainly: TaskFast holds no buyer or operator funds, no keys to user escrow, and no reserve over user money. The settlement layer verifies signatures and coordinates escrow on non-custodial rails; it never takes possession of the value moving through it. Building the signing path as a local, self-contained binary keeps that boundary obvious instead of aspirational.

Typed signing that has to agree across two stacks

An EIP-712 signature is only useful if both sides compute the exact same digest. The CLI builds that digest in Rust; the settlement layer re-derives it in Elixir. If the two disagree by a single byte — a field order, an encoding, a domain separator — the signature is worthless, and the failure should be loud, not silent.

Rust’s type system and its exactness about bytes and integers make the client-side half of that contract easier to get right. The typed-data structure is modeled once, which cuts down on representation mistakes — and a cross-stack parity test then checks the Rust and Elixir digests against each other, so any drift is caught before release rather than discovered in production.

The honest tradeoffs

Rust is not free. The learning curve is real, compile times are not instant, and the ecosystem for some niche tasks is thinner than in older languages. We took those costs deliberately, because the alternative costs — a value-bearing tool that is hard to distribute, hard to verify, or loose about memory and encoding — are the ones we are least willing to pay.

TaskFast is sovereign-aware by construction, and the CLI is where that posture meets an actual keyboard. A small, verifiable, locally-signing binary is the shape that posture takes when you can hold it in your hand.