Skip to main content
praisonai run agents.yaml --continue resumes a whole team exactly where it left off — prior turns and per-agent chat history replay before your new prompt.
Upgrade note (PraisonAI PR #3637). Team --continue is now memory-independent and deterministic — it uses the same durable SessionStore as single-agent --continue. Sessions saved by earlier releases still resume via a one-time legacy fallback through shared_memory. No YAML changes, no new flags, no new params — behaviour just gets more reliable.
The recorded model is restored here too. praisonai run agents.yaml --continue follows the same run_main path, so with no explicit --model the team resumes on the model it was recorded with. See Session Model Restore.

​
Quick Start

1

Run your team once

The run auto-saves to a project-scoped session — no memory: true needed in your YAML.
2

Continue the team later

The most recent root session for this project resumes; each agent’s prior findings replay before your new prompt.

​
How It Works

The adapter resolves the session, restores team state and per-agent chat history, runs astart(), then captures fresh history back into state on save. YAML/team runs go through the same core APIs as single-agent runs — AgentTeam.restore_session_state and AgentTeam.save_session_state. No new params, no YAML changes.

​
Durable State Guarantees

Team state rides the same crash-safe write path as single-agent --continue.

​
Configuration Options

restore_session_state

Core API that rehydrates team state on resume

save_session_state

Core API that persists team state after kickoff

​
What Gets Persisted

Team state and per-agent chat history survive a resume via the durable SessionStore; shared memory is optional enrichment. What does not persist: running tool subprocesses, in-flight streaming state, InteractiveRuntime (ACP/LSP) sessions, and ephemeral in-memory tool caches.

​
User Interaction Flow

A research team YAML runs Monday and continues Wednesday with every agent’s prior findings intact.
On Wednesday the adapter resolves Monday’s session, restores team._state, re-injects each agent’s captured chat history, then runs the new prompt — the researcher, analyst, and writer all pick up their earlier context.

​
Common Patterns

Resume yesterday’s team run:
Use an explicit named session:
Fork to try a variation without touching the main thread:
Throwaway run for PII-sensitive input:

​
Best Practices

Git-remote / root-commit identity resolves consistently from the repo root, so --continue always finds the right session.
--fork --session <id> branches the thread — the parent session is left untouched while you try a variation.
Nothing hits disk after kickoff, so PII-sensitive or throwaway prompts leave no session trail.
Session resume no longer needs memory: true. Team --continue writes and reads team state through the durable SessionStore, so a team declared with memory: false (or no memory: at all) resumes just as reliably as one with shared memory enabled. Add memory: true when your agents genuinely need cross-turn semantic recall — not for resume itself.

Project Sessions

How project identity and the session store resolve --continue

Run Command

Full praisonai run reference with session flags

Run Stream Events

Stream YAML / team runs as per-agent NDJSON with --output stream-json

Session Store

The durable, project-scoped store that now backs team resume too