> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Tasklease: A Task Board for Agents Working Across Machines

[ View on GitHub ]

Tasklease: A Task Board for Agents Working Across Machines

Correction (16 November 2026): This article replaces an earlier version with incorrect API examples and overstated claims about duplicate execution, scaling, and pickup latency.

Hook

Suppose a developer is building a node-based video compositor on Windows. Codex can edit the project there, but a macOS machine must verify its build and render behavior, a Linux machine must run its own checks, and an Opus 5.5 session on another machine can review a design decision. The hard part is not sending a prompt. It is making each request durable, knowing which machine took it, and getting the answer back after a laptop sleeps or a worker restarts.

Tasklease supplies the coordination layer for that arrangement. It does not ship a video compositor, Codex integration, Opus integration, or a ready-made render farm. The application defines those jobs and handlers on top of its task board.

Context

Tasklease is a Python client and worker runtime backed by a Cloudflare Worker, SQLite Durable Objects, and R2 for large files. A requester creates a task in a domain and topic. A machine with a scoped identity owns work on that topic, runs an application handler, and consumes the task while posting its reply or follow-on tasks. The requesting agent can persist a reply locally before acknowledging the server copy. Workers need outbound HTTPS, which makes machines behind ordinary home or office routers usable without exposing a broker. The project documents macOS, Linux, and Windows setup. Source: README

For the compositor example, verify/macos and verify/linux could be topics served by platform-specific workers. A request could carry a repository URL, exact commit, test command, expected artifact, and reply topic. An advice/opus topic could be served by a handler that invokes the separately configured Opus session and returns its review. These topic names and handlers are application choices. Tasklease handles the lease, identity scope, reply, and handoff; each host still needs its checkout, toolchain, model access, and safe execution policy. The repository's own example sends a commit to a Linux verification worker and explicitly says that the project using Tasklease supplies the verification handler. Source: README example

Technical Insight

The key operation is Own. Claiming a task rotates its ID. Renew extends the lease without rotating it. Consume accepts the current ID, retires that task, and atomically posts up to 16 successors in the same domain. If a lease expires and another worker owns the task, the previous worker's Consume cannot post a reply or downstream tasks with the stale ID. This fences Tasklease's own task-board transition. It does not prevent two workers from executing the same external build or writing the same artifact; handlers still need idempotence or their own safeguards for outside effects. Source: API and recovery

That atomic handoff is useful beyond a linear chain. A render check could create independent macOS and Linux verification tasks, or a stage could post both content and security review tasks. Each handler decides which successors to post. Tasklease does not supply a durable workflow engine that joins all those results, runs timers, or compensates failed stages. An application can build fan-in using its own state, as the repository's crawler example does by writing findings to separate columns before assembly. Conditional branching is likewise a handler decision, rather than a missing ability to post a different successor. Source: pipeline example and scope

Request and reply have more than a bare queue's “put and get” behavior. The requester stores replies locally before acknowledging them. Tasklease carries a stable origin_id across Own and Consume so a reply can be associated with its original request. A caller can use an idempotency key to recover an uncertain submission, and can cancel an initial request before its first Consume, including while held. Cancellation does not retract successors already created by that Consume or undo work outside Tasklease. Those are useful boundaries when a long platform verification or model review may outlive the session that requested it. Source: recovery and monitoring

The worker runtime handles lease renewal while a handler runs. The handler gets a lost event to stop cooperative work after it loses the lease. Workers can reserve a local slot, such as a GPU or build slot, before claiming work. A developer could therefore give each compositor host its own capacity policy and topic permissions instead of forcing every machine into the same worker configuration. R2 blob helpers and presigned URLs carry logs or render artifacts too large for a task payload. Source: worker handler and blob guidance

Scale and operational limits

The central scaling unit is a domain: one Durable Object and one database. The documented 10,000–100,000 outstanding tasks per domain is an initial planning range for roughly 1–16 KiB payloads on a paid Workers plan, not a hard queue limit. The README says a million tasks can form a backlog, while operations that scan held tasks or count them all become slower and compete for that domain's capacity. Independent workloads can use separate domains. Consume's atomic successors stay within one domain, so a pipeline that depends on that transaction should be designed accordingly. Source: scale guidance

The project's deployed-service test reports 5,000 workers polling one domain without errors and about 1,000 requests per second served by one domain in a separate load condition. Those figures are not a promise about every production workload. They are also different measurements from the number of queued tasks. The shared identity registry had not been tested past 5,000 tokens in the cited test. Source: load test

Pickup latency depends on how workers wait. In the repository's long-poll experiment, five waiting workers had 266 ms median, 773 ms p95, and 1,947 ms p99 pickup; 1,000 waiting workers had 87 ms median, 169 ms p95, and 228 ms p99. These are measurements from the project's test deployment, not a general service-level objective. The article should not turn the five-worker p99 into a claim that Tasklease categorically cannot assign work in under a second. Source: load test

Gotcha

Tasklease is a framework for discrete cross-machine jobs, not a complete application workflow. The compositor team must provide the platform test commands, an Opus invocation if desired, artifact naming and storage rules, retry policy after an application failure, result aggregation, and any broader workflow cancellation. It must also decide which effects can be safely retried. A fenced Consume prevents a stale worker from posting Tasklease successors; it does not make external effects exactly once. Source: choosing Tasklease

Deployment uses the operator's Cloudflare account. The packaged CLI provisions the Worker, Durable Objects, bucket, and secrets, but the operator still creates R2 access keys, upgrades the service, and manages scoped machine tokens. The project offers a local dashboard and offline fake board for testing, while application-specific observability remains the application's job. Source: deployment and testing

Verdict

Use if: you are building a system in which agents and machines exchange jobs that take seconds to hours, especially when the workers are on different operating systems and networks. Tasklease offers durable requests and replies, lease renewal, scoped identities, blob transfer, and atomic in-domain handoffs on which to build your own handlers. A cross-platform compositor project is a concrete fit for platform verification and remote design review.

Choose a fuller workflow engine if: you need the coordination service itself to own joins, durable timers, compensation, and a queryable record of an entire run. Choose a high-throughput queue if: your workload needs thousands of messages per second or a strict pickup-latency objective. Those are distinctions between products and workloads, not claims that Tasklease cannot be extended for complex applications. Source: choosing Tasklease