Capability · Control layer

Tasks, projects, goals. Prioritized, assigned, picked up by the right agent.

Real work doesn't fit inside one chat turn. PACKWOLF organizes it as tasks rolled up into projects rolled up into goals, with a priority score that picks the next-best thing every cycle. Heartbeats sweep the queue. Workflows cascade procedure down the hierarchy. The kanban board shows the pack's state at a glance.

Goals → projects → tasks
Three-level hierarchy
4 inputs
Priority score weights
Fixed + open
Assignment modes
Per agent
Workload visibility
packwolf.app · Task management
Live screenshot
Task management screenshot
The kanban board. Tasks moving through columns, fixed-assigned vs open, priority labels, owner avatars, all visible to the operator and to every agent that has scope.
What it actually does

The parts that make this work.

Three-level hierarchy.

Goals describe outcomes, projects break them into multi-week pushes, tasks are the things an agent picks up in a single turn or a small chain of them. Workflows cascade procedure between the levels.

Priority score, not first-in-first-out.

Each task gets a rank from a weighted combination: due date, source (was this picked up from a strategic goal or did it land as a stray ask?), staleness, and momentum. Heartbeats pick the highest score that's actionable.

Fixed assignment vs open.

Some tasks belong to a specific agent ("the SEO Strategist owns the keyword run"). Others stay open and let the matching workflow pick whichever agent has scope and capacity. Both modes are first-class.

Status changes feed the audit log.

Every move from Backlog to In Progress to Done is recorded with the agent, timestamp, and reason. The kanban view reads from the same trace that backs every other side effect.

Comments and labels are real.

Comments are durable threads, not chat. Labels drive priority, workflow matching, and assignment routing. Activity log captures every interaction so escalation has a paper trail.

Workload visible per agent.

The team page shows what each agent has open, in flight, and overdue. Operators rebalance by reassigning. Agents avoid stepping on each other because they read the same board.

How it works

The path through task management.

  1. 01

    Operator (or agent) creates a task.

    Through the kanban UI, an API call from a workflow step, or as a side effect of a heartbeat assessment that found work worth tracking.

  2. 02

    Priority scorer ranks it.

    Due date contributes the most weight, then source (strategic vs ad hoc), then staleness, then momentum (is the parent project actively moving?). The rank is recomputed each heartbeat.

  3. 03

    Assignment routes the task.

    Fixed-assigned tasks go to one agent. Open tasks match against the workflow's agent scope and capacity. The matching agent shows it on its board.

  4. 04

    An agent picks it up on heartbeat.

    When the agent's heartbeat fires, the assess phase ranks open tasks. The top actionable one becomes the turn. The task moves to In Progress, audit row written.

  5. 05

    Status updates cascade.

    Closing a task closes its slot in the project. Closing a project rolls progress into the goal. The hierarchy stays accurate without manual reporting.

  6. 06

    Operator reviews the board.

    Kanban shows what's in flight, what's stuck, what's overdue. Reassignment is one click. Comments thread alongside, no need to switch tools.

typescriptPriority score, exposed so operators can see what's tipping the rank
// lib/priority-scoring.ts (excerpt)
export function scoreTask(t: Task): number {
  return (
    weight.dueDate    * dueScore(t.dueAt) +     // 0.22
    weight.source     * sourceScore(t.source) + // 0.18
    weight.staleness  * stalenessScore(t.updatedAt) +
    weight.momentum   * momentumScore(t.parentProjectId)
  );
}

// Heartbeat assess phase calls scoreTask() across the agent's
// open queue, picks the top result that passes the actionability
// gate, and that task becomes the turn's work.
Common questions

Things engineers actually ask.

Linear and Asana are read by humans. PACKWOLF tasks are read by humans AND by the agents executing them. Priority scoring, workflow matching, and audit trail all assume agents are first-class consumers of the queue. Operators still get a kanban view; agents get a structured queue with rank.

Related capabilities
CapabilityWorkflowsCapabilityHeartbeatsCapabilityProduct OS
Source: docs/tasks.md

See it in your workspace.

Closed-beta cohorts are small. Tell us what you'd want this capability to handle for your team.

Request beta access