zeekayandHanzo Dev e0c8182042 store: shards may keep their rows on a shared SQL server
TASKSD_STORE=sql keeps every shard's rows in one table, tasks_kv, on the
hanzoai/sql server TASKSD_SQL_ADDR names (its ZAP listener), so a process running
the engine keeps nothing on disk and any process can take its place. A shard is
(principal, ns), the same value it always was; its rows are a fileKV in its own
SQLite file or an sqlKV in the table, behind one rows interface. Keys are bytea
compared as bytes, so a scan walks keys in exactly a shard file's order whatever
the server's collation; each value is sealed (AES-256-GCM) under the key a shard
file of the same tenant and namespace derives from the master, bound to its shard
and key, so the server holds only ciphertext. A shared store refuses to open
without a master key.

Copy moves every shard from one manager to another a page at a time, leaves the
destination holding the source's rows and no others, and proves each shard by
count and a SHA-256 over its rows in key order. SQLite stays the default; nothing
changes for a deployment that sets nothing.

Proved against a hanzoai/sql test server: scans equal a file shard's for UTF-8,
DEL and prefix-boundary keys; the server holds no plaintext; a crashed engine
recovers a workflow mid-activity from the table into a fresh data directory, the
activity running exactly once.

Co-authored-by: Hanzo Dev <[email protected]>
2026-10-03 19:03:47 -07:00
2026-08-02 09:45:33 -07:00
2026-08-29 13:46:59 -07:00
2026-10-03 12:19:56 -07:00
2026-06-28 20:09:59 -07:00

tasks

Hanzo Tasks

Durable workflow execution engine for AI agent orchestration.

GitHub License

Introduction

Hanzo Tasks is a durable execution engine that powers AI agent orchestration in the Hanzo ecosystem. It enables developers to build scalable, fault-tolerant workflows that automatically handle intermittent failures and retry failed operations.

Tasks provides the backbone for:

  • Playground spaces -- each space maps to a Tasks namespace
  • Agent execution -- each agent runs as a Tasks worker
  • Durable cron and batch jobs -- reliable scheduled and bulk operations

MIT licensed. See LICENSE.

Getting Started

Build

make tasksd

Run

./tasksd start

Or with a config file:

./tasksd --config-file config/development-sqlite.yaml --allow-no-auth start

Build from source

go build ./cmd/tasksd/
./tasksd start

Module

github.com/hanzoai/tasks

Integration

Hanzo Tasks integrates with the broader Hanzo ecosystem:

  • Playground connects to the Tasks server via the durable-execution SDK
  • Base embeds Tasks for durable cron/batch execution
  • Each playground space = a Tasks namespace
  • Each agent = a Tasks worker

Repository

This repository contains the source code of the Hanzo Tasks server. The wire is luxfi/zap (binary, native, on _tasks._tcp:9999). There is no gRPC and no go.temporal.io anywhere in the build.

To drive Tasks from Go, depend on pkg/sdk — the native ZAP client. To embed the server in a Go process (e.g. a Hanzo Base app), depend on pkg/tasks and call tasks.Embed().

Browser clients hit the JSON shim at /v1/tasks/* and the realtime stream at /v1/tasks/events (Server-Sent Events). AI agents hit the MCP surface at /v1/tasks/mcp (JSON-RPC 2.0).

Contributing

See CONTRIBUTING.md for development setup and guidelines.

License

MIT License

S
Description
No description provided
Readme MIT
139 MiB
Languages
Go 85.4%
TypeScript 12.3%
ZAP 1%
Shell 0.6%
Dockerfile 0.4%
Other 0.2%