PAIA Workboard Skill | Agent Skills

PAIA Workboard

Overview

Use paia-work as the canonical PAIA workboard service. It is a FastAPI HTTP/WS facade over Workgraph, backed by paia-work/.workgraph/graph.jsonl and the wg CLI.

Default paths can be configured with environment variables:

Repo: ${PAIA_WORK_ROOT:-<workspace-root>/paia-work}
API: ${PAIA_WORKBOARD_URL:-http://127.0.0.1:3560}
Workgraph: ${PAIA_WORK_ROOT:-<workspace-root>/paia-work}/.workgraph
CLI: cd "$PAIA_WORK_ROOT" && uv run workboard ...

New Session Startup

When the user starts a fresh agent session and asks to work with the PAIA Workboard, the agent should treat this skill as the operating manual and start from the Workboard control plane.

Good trigger phrases include:

"work with me on my PAIA Workboard"
"review my Workboard"
"triage the board"
"take over something from the board"
"what can an agent run from my Workboard?"

Default startup flow:

cd <workspace-root>/paia-work
uv run workboard list --agent-runnable --limit 20
uv run workboard waiting --limit 20
uv run workboard sessions

Then summarize:

active focus items
waiting/watch items that should not consume user attention
agent-runnable tasks
active agent/tmux sessions
any task that is blocked, stale, or needs human input

Ask what to start only when the board does not make the next step obvious.

First Checks

Before changing board state:

Check the Workboard CLI:

cd <workspace-root>/paia-work
uv run workboard list --limit 5

Check service health if the CLI cannot reach the API:
```
curl -sS http://127.0.0.1:3560/api/status
```
Check Workgraph orientation only when falling back below the Workboard API:
```
cd <workspace-root>/paia-work && wg quickstart
```

If the API is down but the repo exists, use:

wg --dir <workspace-root>/paia-work/.workgraph list
wg --dir <workspace-root>/paia-work/.workgraph ready
wg --dir <workspace-root>/paia-work/.workgraph show <task-id>

Working With the User

When the user asks to work from the board:

Start by listing relevant open/ready tasks and summarize the smallest useful set.
Ask which task to start only when the board does not make the next task obvious.
Prefer explicit task IDs in conversation and logs.
Before marking work done, record what changed and any verification result.
Create follow-up tasks for real remaining work rather than burying TODOs in chat.

Workboard CLI Operations

Use the workboard CLI first for normal task and agent-session operations. This applies to Codex, Claude/OpenCode, PAIA agents, Sam-style agents, and any other local agent that needs to read or mutate Workboard state. Agents should call workboard before writing custom curl/JQ glue.

cd <workspace-root>/paia-work

uv run workboard list --agent-runnable
uv run workboard list --board focus --activity active-collab
uv run workboard show <task-id>
uv run workboard waiting
uv run workboard deps <task-id>
uv run workboard watch <task-id>
uv run workboard claim <task-id> --agent codex
uv run workboard tag <task-id> --add activity:active-agent --remove activity:ready-delegate
uv run workboard log <task-id> "Progress note"
uv run workboard artifact <task-id> /path/to/report.md --summary "What changed"
uv run workboard done <task-id> --agent codex
uv run workboard fail <task-id> "Reason"
uv run workboard sessions

Use list filters instead of ad hoc curl | jq for common board questions:

uv run workboard list --board focus
uv run workboard list --activity waiting
uv run workboard list --mode agent-solo
uv run workboard list --cluster paia-control-plane
uv run workboard list --tag triage:codex-ready

To hand a task to a new tmux-backed Codex agent:

uv run workboard run <task-id> \
  --agent codex \
  --tmux per \
  --window <short-window-name> \
  --cwd <workspace-root>

This should claim the task, log the handoff, create a tmux window, start the agent command, send the Workboard task prompt, and log the tmux target back to the task.

If workboard lacks a needed operation, fall back to the HTTP API. If the API is unavailable, fall back to wg for direct Workgraph inspection only.

HTTP Operations

Use HTTP for board CRUD when the Workboard CLI does not expose the operation yet.

List tasks:

curl -sS 'http://127.0.0.1:3560/api/tasks'
curl -sS 'http://127.0.0.1:3560/api/tasks?status=open'
curl -sS 'http://127.0.0.1:3560/api/tasks?assigned_agent_id=codex'
curl -sS 'http://127.0.0.1:3560/api/tasks/ready'

Show one task:

curl -sS 'http://127.0.0.1:3560/api/tasks/<task-id>'

Create a task:

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks' \
  -H 'Content-Type: application/json' \
  -d '{"title":"Task title","description":"Context and acceptance criteria","tags":["board:paia"],"assigned_agent_id":"codex"}'

Update a task:

curl -sS -X PATCH 'http://127.0.0.1:3560/api/tasks/<task-id>' \
  -H 'Content-Type: application/json' \
  -d '{"description":"Updated context","add_tag":["needs-review"]}'

Claim, log, comment, complete, fail, or unclaim:

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/claim' \
  -H 'Content-Type: application/json' -d '{"actor":"codex"}'

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/log' \
  -H 'Content-Type: application/json' -d '{"message":"Progress note"}'

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/comments' \
  -H 'Content-Type: application/json' -d '{"author":"codex","body":"Comment body","actor_type":"agent"}'

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/done' \
  -H 'Content-Type: application/json' -d '{"actor":"codex"}'

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/fail' \
  -H 'Content-Type: application/json' -d '{"reason":"Why it failed"}'

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks/<task-id>/unclaim'

CLI Operations

Use wg directly for dependency graph inspection, coordinator status, and fallback state management:

cd <workspace-root>/paia-work
wg service status
wg list
wg ready
wg show <task-id>
wg viz
wg agents

When the coordinator service is running, define work and monitor it; avoid manual wg claim or wg spawn unless the user explicitly wants manual execution.

For manual mode:

wg claim <task-id>
wg log <task-id> "Progress note"
wg done <task-id>
wg fail <task-id> --reason "Reason"
wg unclaim <task-id>

Task Creation Guidance

Good workboard tasks include:

Clear title with the expected outcome.
Description with context, constraints, and links/files.
Validation section for code work.
Dependencies via blocked_by in HTTP or --after in CLI.
Tags such as board:paia, product area, urgency, or review state.

HTTP dependency example:

curl -sS -X POST 'http://127.0.0.1:3560/api/tasks' \
  -H 'Content-Type: application/json' \
  -d '{"title":"Follow-up task","description":"Do this after prerequisite completes","blocked_by":["prereq-task-id"],"tags":["board:paia"]}'

CLI dependency example:

cd <workspace-root>/paia-work
wg add "Follow-up task" -d "Context and validation" --after prereq-task-id

Safety

Treat the workboard as shared state; inspect before mutating.
Do not delete or abandon tasks unless the user asks or the task is clearly a duplicate/error.
Do not use unrelated task systems for PAIA workboard state.
If code changes are made while working a board task, follow the target repo's local AGENTS.md and validation instructions.

Agent Skills: PAIA Workboard

Install this agent skill to your local

Skill Files