workgraph

work fast
task graphs for humans and agents
self-organizing process flowgraphs
cybernetic autopoietic stigmergic medium

Building complex systems requires coordination at the same scale. Workgraph is a dependency graph of tasks — completing one unblocks the next. A coordinator dispatches AI agents to ready work. Each agent receives context from upstream, executes autonomously, and reports results back to the graph.

For teams and individuals who coordinate humans and AI agents on complex projects. No server, no account — just a .workgraph/ directory in your repo.

dependency graphs

Fan out into parallel subtasks. Fan in at synchronization points. Cycles with bounded iterations handle repeating workflows like CI and review.

agent isolation

Each agent gets its own git worktree. Parallel execution without merge conflicts. Commit, push, and report back independently.

TUI dashboard

Monitor the entire graph in real time. Inspect tasks, view agent logs, navigate dependencies — all from the terminal.

evaluation & evolution

Four-dimensional scoring after every task. An evolver recombines the best-performing roles and tradeoffs. The organization improves itself.

verification & FLIP

--verify attaches machine-checkable gates to tasks. FLIP probes latent intent fidelity. Failed checks auto-generate repair tasks.

communication

wg chat for interactive coordinator conversations. wg msg for inter-agent messaging. Matrix, Telegram, Slack, email notifications.

analysis & planning

Find bottlenecks, trace the critical path, forecast completion dates, and balance workload across agents. The graph knows what's blocking you.

$ wg viz

design-api  (done) 2d
├→ build-auth  (done) 2d ──────────────┐
├→ setup-db  (done) 1d                 │
│ ├→ api-docs  (open) 1d ───────────────┤
│ ├→ recipe-crud  (in-progress) 6h ────┤ ←─┐
│ │ └→ review  (open) 1d ↺ (iter 0/3) ──┼ ──┘
│ └→ search  (open) 1d ─────────────────┤
└→ deploy  (open) 1d ←──────────────────┘
  └→ int-tests  (open) 1d

Fan-out decomposes. Fan-in synchronizes. Arcs show convergence. Cycles with bounded iterations handle repeating workflows. Stored in .workgraph/graph.jsonl — git-friendly, no server, no account.

cycles

Processes that repeat — CI, monitoring, convergence — are cycles in the graph. Each has a bound. Agents pick up where previous iterations left off.

run-tests  (in-progress) 3h ↺ (iter 0/5) ←─┐
└→ fix-failures  (open) 3h                 │
  └→ push-check  (open) 3h ────────────────┘

organizational synthesis

Agents have roles (what they do) and tradeoffs (how they prioritize). Each task gets scored. An evolver recombines the best performers. The organization restructures itself.

$ wg agency stats

Role       Tradeoff  Avg
-------------------------
Programmer Thorough  .93
Writer     Balanced  .88
Analyst    Balanced  .88

built with itself

Workgraph coordinates its own development. Every feature, bug fix, and documentation page is a task in the graph — dispatched to agents, evaluated, and evolved. The tool that builds the organization is built by the organization.

Workgraph TUI showing its own task graph during development

$ wg status

  Tasks       1,724 (1,702 done)
  Commits       734
  Evaluations 2,304 (avg 0.79)
  Agents          8 concurrent
  Roles          24 (33 tradeoffs)

This page was written by a workgraph agent, reviewed by another, and deployed through the same dependency graph it describes.

get started

Install with Rust (Linux, macOS, Windows):

cargo install --git https://github.com/graphwork/workgraph

Then start a project:

$ wg init
$ wg add "Design auth API"
$ wg add "Implement endpoints" \
    --after design-auth-api \
    --verify "cargo test passes"
$ wg add "Integration tests" \
    --after implement-endpoints
$ wg service start --max-agents 4
$ wg chat "What's blocking auth?"

The service dispatches agents, verifies results, evolves the agent population, and loops. You define structure. It does the rest.