Continuous Conversations

A resumed turn keeps the agent's working memory. A stateless turn keeps only the words. That is why long, multi-step work belongs in the Workspace: an agent that read three files in turn two still has them in turn six, instead of re-reading them.

Turns on one chat are serialized. Two simultaneous resumes of the same session could corrupt it, so a second message while one is in flight is refused rather than queued. Start another chat if you need parallel work against the same agent.

If the underlying session file has gone missing, the platform recovers automatically: it retries once as a cold turn, re-attaching the conversation history. You get an answer; the agent has the transcript but not its prior working state.

A turn is bounded by the agent's own execution timeout(default one hour, range 1 minute to 2 hours). A turn that hits it fails naming the agent's limit rather than hanging.

When Claude Code's internal history approaches roughly 85% of the model's context window, it:

The window is model-specific, not a flat 200K — a 1M-token model compacts at ~85% of 1M, a 200K model at ~85% of 200K.

What you'll notice: the turn takes a couple of minutes longer than expected, the visible message log is untouched, and working memory survives in compressed form. After several compacts in one conversation the summary loses fidelity and answers get vaguer — that's the point to start a fresh chat.

One turn can use up to 50 internal Claude agentic-loop iterations — read a file, edit it, run tests, retry — before failing with:

Task exceeded turn limit: Reached maximum number of turns (50).
Consider increasing max_turns_task in guardrails or breaking into smaller subtasks.

This is not the number of messages in your conversation. It is the per-turn iteration budget for a single request, and a heavy twelve-step task with retries can exhaust it.

TOKEN=$(curl -s --fail-with-body -X POST http://localhost:8000/api/token \
  -d "username=admin&password=$ADMIN_PASSWORD" \
  | python3 -c "import json,sys; print(json.load(sys.stdin).get('access_token') or '')")
# 403 = correct password, second factor required (no session). Use an MCP API
# key for automation — see api-reference/authentication.md.
[ -n "$TOKEN" ] || { echo "login issued no session" >&2; exit 1; }

curl -X PUT http://localhost:8000/api/agents/<agent-name>/guardrails \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"max_turns_task": 200}'

Starting a new chat gives you a fresh conversation. On an agent's Main chat, Reset archives the conversation and starts the agent cold: the archived chat stays in your list and remains resumable as an ordinary chat, and the new Main has no memory of it. Through the session API, resetclears an existing session's cached memory while keeping its visible log — the next turn is a cold turn.

Reach for a clean slate when the agent is going in circles, when you're switching topic and don't want bleed-over, or when repeated compaction has degraded its answers.

Conversations survive container restarts, and scope is per person: an agent's owner cannot read another user's conversations with it.