A task is ready IF its dependencies are done AND no blocker has appeared. Traditional task systems can't express that. Hence plans are defeasible logic programs — readiness is derived, blockers defeat it, and agents claim tasks as the plan re-reasons. Twenty-one LLM providers. Isolated worktrees. Merged results.
The moment you have more than one LLM agent, you need readiness logic: "task X is ready if A is done, B is reviewed, and no blocker C exists." Task managers model the first condition. Workflow engines bolt the rest on top as code. Neither gives you a plan you can query.
A Kanban board where readiness is a human's judgement and "blocked" is a sticker, not a derivation.
A DAG workflow engine (Airflow, Temporal) that encodes dependencies but can't defeat a task because a blocker rule just fired.
A shell script that launches agents in parallel and hopes they don't step on each other's uncommitted work.
A plan in SPL (Spindle Lisp) — tasks, dependencies, readiness rules, and defeaters that block tasks when conditions warrant it.
Spawn with isolation — each agent gets its own git worktree. Hence merges results back and re-reasons about what's next.
Query the plan — hence query explain task-X tells you exactly why a task is ready, or why-not if it isn't.
A small plan: build a CRUD API. Two agents (coder, reviewer). Click through.
; crud-api.spl (task schema :desc "define models") (task crud :desc "build handlers" :deps (schema)) (task review :desc "code review" :deps (crud)) (task deploy :desc "ship it" :deps (review)) ; readiness rules (defeasible) (defeasible r-ready (done ?x) => (releases ?x)) ; defeater: don't deploy if incidents are open (defeater r-freeze (open-incident ?i) => (not (ready deploy)))
$ hence task next plan.spl ready: · schema no deps, no defeaters waiting: · crud (needs: schema) · review (needs: crud) · deploy (needs: review) # Ready set is *derived*, not hand-maintained. # Adding a blocker changes it without editing the tasks.
$ hence task assign plan.spl schema --agent claude assigned schema → claude $ hence agent spawn plan.spl --agent claude spawning claude in worktree .hence/wt-schema [14:22:01] claude tool=read spec/models.md [14:22:04] claude tool=edit src/models.rs [14:22:11] claude tool=bash cargo check ✓ [14:22:18] claude claim-complete schema merging wt-schema → main ✓ 4 files, 0 conflicts # Each agent isolated; hence merges and re-reasons.
$ hence plan board plan.spl backlog │ ready │ in-flight │ done │ blocked ────────────┼─────────────┼────────────┼──────────────┼────────── │ crud │ │ schema │ deploy │ │ │ │ review │ │ │ │ $ # trigger a blocker $ hence task block plan.spl deploy --reason "open incident" $ hence plan board plan.spl backlog │ ready │ in-flight │ done │ blocked ────────────┼─────────────┼────────────┼──────────────┼────────── │ crud │ │ schema │ deploy review │ │ │ │
$ hence query explain ready-crud plan.spl goal: (ready crud) [+d] └─ rule r-ready crud-api.spl:9 ├─ (done schema) [+d] claim · wt-schema └─ no defeater fires [+d] $ hence query why-not ready-deploy plan.spl goal: (ready deploy) [-d] blocked by: r-freeze fires on (open-incident i-92) would succeed if: (open-incident i-92) retracted
Plans are Spindle Lisp (SPL) programs, not YAML. Defeasible logic means "normally ready, unless blocker" is a first-class construct. Query the plan and get a derivation.
Each agent claims a task and spawns in its own git worktree. When it's done, hence merges the result back and re-reasons. No more shell scripts that lose work when two agents edit the same file.
Claude, Codex, Qwen, Gemini, Cursor, local Ollama, and fifteen more. Pick per task: use Claude for tricky code review, a fast local model for boilerplate. No vendor lock-in.
The plan is an SPL file. The reasoner is Spindle — the same defeasible engine that proves goals in theories. Tasks are goals; readiness is a conclusion; blockers are defeaters. Agents are the executors.
Task completes → hence re-derives readiness. New blocker → defeats ready tasks. The plan stays coherent.
SPL is text. Review a plan in a PR. Write them by hand, or have an LLM generate one and check it in.
No agent can corrupt another's context. Merge is explicit. Conflicts surface at the merge, not the spawn.
The plan is the source. The board is derived. Drag nothing; the reasoner moves cards for you.
Pipe to jq, to a log shipper, to your own UI. No proprietary bus; everything's a line of JSON.
hence.run hosts plans across machines so teams of agents on separate boxes coordinate via one plan.
Write the plan. Spawn the agents. Query the derivation. Isolated worktrees and merged results, from one text file.
cargo install hence-cli