Agent lifecycle

How an agent is created, runs, becomes a subagent, gets archived, and disappears from the UI. The model spans the daemon (lifecycle, archive) and the client (tabs, the subagents track).

States

initializing → idle → running → idle (or error → closed)
                 ↑        │
                 └────────┘  (agent completes a turn, awaits next prompt)

Each agent in AgentManager carries a lastStatus of initializing, idle, running, error, or closed. State transitions persist to disk and stream to subscribed clients via WebSocket.

Relationships

Agents can launch other agents via the agent-scoped create_agent MCP tool. Agent-scoped creation is always asynchronous. By default, the daemon stamps the created agent with a label paseo.parent-agent-id pointing back at the agent that created it. The client surfaces that as agent.parentAgentId.

Agent-scoped create_agent accepts detached: true for agents that should stand on their own. The daemon still uses the creating agent for cwd/config inheritance, but does not write paseo.parent-agent-id.

Subagents — created with detached: false or omitted. They exist as part of the creating agent's work, appear in that agent's subagent track, and are archived with it.
Detached agents — created with detached: true. They take over as sibling/root agents (e.g. handoffs, fire-and-forget delegations), do not appear in the creating agent's subagent track, and are not archived with it.

notifyOnFinish defaults to true for agent-scoped creation because most subagents are delegated work the creating agent needs to hear back from. Set it to false only for truly fire-and-forget agents.

Tabs vs archive

These are two distinct concepts that used to be conflated:

Concept	Scope	Triggers
Tab (workspace layout)	Per-client	User opens/closes a view
Archive (lifecycle)	Global	Explicit lifecycle gesture

Closing a tab on a root agent still archives — the tab is the agent's home, so closing it means "I'm done with this agent." A confirm dialog protects against archiving a running agent by accident.

Closing a tab on a subagent (any agent with parentAgentId) is layout-only. The agent stays unarchived and stays in its parent's track. The user can re-open the tab from the track at any time. This is implemented in handleCloseAgentTab (packages/app/src/screens/workspace/workspace-screen.tsx).

The asymmetry is intentional: a subagent's home is the parent's track, not the tab. Tabs are ephemeral viewing slots; the track is the persistent record of the parent's children.

Workspace activity

Agent lifecycle status stays literal: a parent agent is idle when its own turn is idle, even if a child is running.

Workspace status is an aggregate activity signal. Root agents contribute their normal state bucket to their own workspace. Running subagents contribute running to their root parent's workspace, not to the subagent's current cwd or worktree. Non-running subagent attention, permission, and error states stay in the parent's subagents track and do not escalate the workspace bucket.

The subagents track

The collapsible track above the composer in an agent's pane (packages/app/src/subagents/track.tsx). Membership rule (packages/app/src/subagents/select.ts):

parentAgentId === thisAgent.id  AND  !archivedAt

Archived subagents disappear from the track, by design. To remove a subagent from the track without closing its tab, use the archive button (X) on the row — it opens a confirm dialog and archives the subagent on confirm. That same archive shows the subagent leave the track on every connected client.

Why this shape

The decision was to decouple "close tab" from "archive" only for subagents, rather than universally:

Closing a tab on a root agent still archives — preserves the existing UX users are trained on
Closing a tab on a subagent is layout-only — fixes the lossy "click to read, close to dismiss view, lose the row" flow
Archive button on track rows — gives subagents an explicit lifecycle gesture in their home surface
Cascade archive on parent — keeps subagents from leaking when the parent is archived

We considered universal decoupling (no tab close ever archives, archive is always explicit) but rejected it: it changes a behavior root-agent users rely on.

Limitations

Subagent accumulation under long-lived parents

A parent that spawns many subagents will see the track grow. There's no automatic cleanup for completed subagents — the user prunes via the archive button on each row. A bulk gesture (e.g. "archive all idle children") could land later if this becomes a real problem.

Cross-client tab dismissal

Closing a subagent's tab on one client doesn't affect other clients' layouts. This is the expected behavior of decoupled tabs and is consistent with how layouts have always worked. Archive remains the global gesture for cross-client cleanup.

Storage

$PASEO_HOME/agents/{cwd-with-dashes}/{agent-id}.json

Each agent is a single JSON file. Fields relevant to this doc:

Field	Type	Meaning
`id`	`string`	Stable identifier
`archivedAt`	`string?`	Soft-delete timestamp (ISO 8601)
`labels["paseo.parent-agent-id"]`	`string?`	Parent agent ID, set automatically by agent-scoped `create_agent` unless `detached: true`
`lastStatus`	`AgentStatus`	`initializing` / `idle` / `running` / `error` / `closed`

See docs/data-model.md for the full agent record.

7.3 KiB Raw Blame History