your first 5 minutes

Workgraph is a single binary. Install it with Rust:

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

    Compiling workgraph v0.1.0
    Finished `release` profile [optimized] target(s)
  Installing /home/you/.cargo/bin/wg
   Installed package `workgraph v0.1.0`

Verify:

$ wg --version

workgraph 0.1.0

Navigate to any project directory and run wg init. This creates a .workgraph/ directory — your task graph lives here, right next to your code.

$ cd my-project
$ wg init

Added .workgraph to .gitignore
Initialized workgraph at .workgraph
Seeded 8 roles and 11 tradeoffs.
Created default agent: Careful Programmer (f5143935).
Enabled auto_assign and auto_evaluate in config.

Agency is ready. The service will now auto-assign agents to tasks.
  Next: wg service start

No server. No account. Just a directory in your repo.

Add tasks with wg add. Use --after to declare dependencies. Task IDs are auto-generated from the title.

$ wg add "Design the API"

Added task: Design the API (design-the-api)
  Use --after design-the-api to depend on this task

$ wg add "Build the backend" --after design-the-api

Added task: Build the backend (build-the-backend)
  Use --after build-the-backend to depend on this task

$ wg add "Write tests" --after build-the-backend

Added task: Write tests (write-tests)
  Use --after write-tests to depend on this task

$ wg add "Deploy to staging" --after build-the-backend,write-tests

Added task: Deploy to staging (deploy-to-staging)
  Use --after deploy-to-staging to depend on this task

See what you built:

$ wg viz

design-the-api  (open)
└→ build-the-backend  (open)
  ├→ write-tests  (open) ────────┐
  └→ deploy-to-staging  (open) ←─┘

deploy-to-staging waits for both build-the-backend and write-tests. Only design-the-api is ready to start — it has no blockers:

$ wg ready

Ready tasks:
  design-the-api - Design the API

The coordinator watches the graph, claims ready tasks, and spawns AI agents to work on them. When an agent finishes, downstream tasks become ready and new agents spin up.

$ wg service start --max-agents 3

Coordinator started (pid 42851)
  Max parallel agents: 3
  Executor: claude
  Watching for ready tasks...

That's it. The service runs in the background. It picks up design-the-api immediately — the only task with no blockers.

Open the terminal UI to see what's happening in real time:

$ wg tui

The TUI shows the task graph, agent activity, and logs updating live. Or check status from the command line:

$ wg agents

PID    TASK               STATUS   ELAPSED
42903  design-the-api     running  2m 14s

$ wg list

[~] design-the-api - Design the API
[ ] build-the-backend - Build the backend
[ ] write-tests - Write tests
[ ] deploy-to-staging - Deploy to staging

When design-the-api finishes, the coordinator immediately spawns an agent for build-the-backend. When that completes, write-tests becomes ready. Once both are done, deploy-to-staging unblocks.

$ wg viz

design-the-api  (done)
└→ build-the-backend  (done)
  ├→ write-tests  (done) ────────┐
  └→ deploy-to-staging  (in-progress) ←─┘

You defined the structure. The graph did the rest.