hence

hence

A CLI for multi-agent LLM task coordination using defeasible logic. Multiple agents query the same plan, claim tasks, record findings, and drive work to completion — locally or across machines.

Get started Core concepts

Quick start

curl -fsSL https://files.anuna.io/hence/latest/install.sh | bash
hence plan translate my-spec.md -o plan.spl
hence agent watch plan.spl --spawn --agent claude
# now go get some sleep!

What is hence?

hence is a coordination layer for multi-agent workflows. You write a plan as a set of logical rules — which tasks exist, when they're ready, and who should do them — and the hence reasoner evaluates those rules to answer questions like "what should I work on next?" or "why is this task blocked?"

The underlying logic is defeasible: rules can be overridden by more specific rules. This lets you express nuanced policies ("normally the coder does this, but if it's security-sensitive, the security agent takes it") without complex imperative code.

Plans are plain text files (.spl) that grow over time as agents assert new facts. Multiple agents can work on the same plan file — or share it via hence.run for coordination across machines.

Beta software. hence is under active development. APIs, CLI flags, and plan syntax may change between releases.

Architecture

flowchart TD
    spawn["hence agent spawn<br>PTY + worktree"]
    claude["LLM Agent<br>(claude)"]
    codex["LLM Agent<br>(codex)"]
    gemini["LLM Agent<br>(gemini)"]
    sup["Supervisor + Evaluator<br>roles"]
    cli["hence CLI<br>task next / done<br>task claim / assert / complete"]
    plan[("plan.spl · plain text<br>defeasible rules + accumulated facts<br>local file · hence.run URL")]
    spawn -.-> claude & codex & gemini
    spawn --> sup
    claude & codex & gemini --> cli
    cli -.-> spawn
    cli & sup --> plan
    classDef agentStyle fill:#6366f1,stroke:#4338ca,color:#fff
    classDef cliStyle fill:#8b5cf6,stroke:#7c3aed,color:#fff
    classDef spawnStyle fill:#06b6d4,stroke:#0891b2,color:#fff
    classDef supStyle fill:#14b8a6,stroke:#0d9488,color:#fff
    classDef planStyle fill:#1e293b,stroke:#0f172a,color:#e2e8f0
    class claude,codex,gemini agentStyle
    class cli cliStyle
    class spawn spawnStyle
    class sup supStyle
    class plan planStyle

Documentation

Getting Started

Install hence and complete your first task lifecycle end-to-end.

Core Concepts

Defeasible logic, plans, tasks, agents, and the reasoner explained.

Writing Plans

SPL syntax, metadata, readiness rules, assignments, and best practices.

Agent Workflow

The standard agent loop, multi-agent coordination, and hence.run.

Supervision

Spawn-based supervision, lease claims, liveness, and failure handling.

Plugins

Extend hence with custom commands, providers, hooks, validators, and formatters.

LLM Integration

Prompt patterns, SPL reference, and operating hence as an LLM agent.

CLI Reference

Every command, flag, and option with examples.

Key features

  • Defeasible logic — rules can be overridden by more specific rules; no imperative glue code
  • Self-documenting plans — (meta ...) blocks make plans queryable and explainable
  • Explainable reasoning — hence query explain shows exactly why a conclusion was reached
  • LLM-first — hence llm spl outputs the full SPL reference for LLM context windows
  • Plan decomposition — hence plan decompose expands a task into subtasks using abductive reasoning, with formal validation against the parent plan
  • Agent supervision — hence agent watch --spawn is the supervisor loop; hence agent spawn executes a single task with lease management, liveness monitoring, retries, and evaluation
  • P2P coordination — share plans via hence.run or peer-to-peer passphrase for multi-machine workflows
  • Fast reasoning — the spindle-rust engine evaluates typical plans in under a millisecond; 1000-rule theories resolve in ~2 ms
  • Single binary — no runtime, no daemon required for basic use
  • JSON everywhere — every read command supports --json for scripting and piping