Logs
This page lists the log lines an app environment writes, grouped by the part of the server that writes them, and says what a log line must never contain.

An app environment writes its log to standard output, one line per event. This page lists those lines, so you can search a log for the right text. If you are following a problem, start from troubleshooting and come back here for the exact line.

The first thing to check: a line starts with a tag in square brackets, such as [agents/runs]. Search the log for the tag of the part you are looking at.

Levels

Log lines carry IDs, counts, statuses, sizes, timings and trigger sources. They never carry secrets.

There are four levels: debug, info, warn and error. You set the lowest level to print with SEED_APPS_LOG_LEVEL or --log-level. The default is info. The code is in apps/src/log.ts.

Only some lines obey the level:

    The lines that fire on every poll log at debug, so they are silent by default: Polling feed, Feed page received and Checked activity against trigger. Processing feed events logs at debug when a poll found nothing new, and at info when it found events.

    The slow-statement line and the [agents/retention] lines also obey the level.

    Every other line on this page is written straight to the console. It prints at every level.

Set the level to debug when you trace why a trigger did or did not fire.

One thing is not a log line. While a model writes a reply, the server also writes the reply text to standard output. It does not do this for a private session.

Triggers and the activity feed

The activity monitor reads the feed of new events. Trigger matching decides which events fire a trigger. These are their lines:

    [Agents Activity] Polling feed

    [Agents Activity] Feed page received

    [Agents Activity] First poll processing events

    [Agents Activity] Processing feed events

    [Agents Activity] Poll failed

    [Agents Activity] Poll aborted mid-cycle

    [Agents Activity] Poll cycle aborted, skipping remaining accounts

    [Agents Trigger] Skipping activity without stable key

    [Agents Trigger] Checked activity against trigger

    [Agents Trigger] Skipping duplicate trigger firing

    [Agents Trigger] Skipping run-completed trigger already in this chain

    [Agents Trigger] Fired trigger

    [Agents Trigger] Trigger session run enqueued

    [Agents Trigger] Trigger session dispatch failed

    [Agents Trigger] Trigger started headless run

    [Agents Trigger] Trigger woke a parked run

    [Agents Trigger] Trigger fired with no run listening

    [Agents Trigger] Trigger firing failed

    [Agents Trigger] Started sessions of firings left waiting

The server also keeps its triggers in step with trigger documents, and the names of its agents in step with their mount documents. Those tasks write:

    [Agents Trigger Documents] Synced trigger documents

    [Agents Trigger Documents] Published stored triggers as documents

    [Agents Triggers] Published a stored trigger as a document

    [Agents Triggers] Trigger stays stored on the server

    [Agents Triggers] Could not sync trigger documents

    [Agents Mount Names] Renamed mounted agents after their documents

    [agents/mount] could not read the mount document for a name check

Triggers describes the monitors that write these lines.

Startup and the run queue


    [agents/boot] step finished, [agents/boot] recovery finished, [agents/boot] recovery failed

    [agents/sqlite] connection settings

    [agents/runs] boot sweep requeued interrupted runs

    [agents/outbox] boot sweep settled effects a dead process left running

    [agents/outbox] pruning receipts failed

    [agents/runs] boot reconcile: replaying finished child into parked parent

    [agents/runs] dispatch paused, [agents/runs] dispatch resumed

    [agents/runs] dispatch pump failed

    [agents/runs] activity woke a waiting run

Startup and shutdown and the run queue explain what these steps do.

One agent run

Every line of one agent run starts with [agents/runtime] and carries the sessionId, the agentId, the provider and the model. In the order a turn usually writes them:

    agent run starting

    resuming the durable turn an earlier process left unfinished

    turn already answered in the durable conversation; nothing to run

    sending provider request

    provider first output, with ttftMs, the time to the first output

    assistant text streaming

    assistant turn complete, or assistant turn reported error

    tool call start, then tool call end or tool call failed

    tool call answered from its receipt, tool call recovered from what its effect left behind, tool call answered as interrupted

    recording a tool effect failed, recording a tool receipt failed

    turn ended after tool batch, turn ended silently, ending turn before the next provider request

    the model sent nothing for too long; ending the turn

    agent run finished, or agent run threw

A run that picked up a turn left by an earlier process carries resumed: true on its agent run finished line.

Other [agents/runtime] lines:

    sub-session spawned, sub-session resolved

    plan step settled from children

    agent started session, agent-started session run failed

    session continued, continuation could not carry attachment

    session titled by model, session title generation failed, ignored agent session title update

    learned reasoning efforts the model accepts; the next request will use them

    durable task failed, durable harness reported, harness event handling failed, aborting the durable turn failed, durable store close failed

Scripts

    [agents/workflow] workflow spawned from chat

    [agents/workflow] continued as new run

    [agents/workflow] run paused on its time budget

    [agents/workflow] replay finished with unconsumed journal groups

The database, sandboxes and other parts

    [agents/sql] slow statement, at warn: a prepared statement ran for more than 20 ms. See diagnosing a stalled server.

    [agents/retention] scheduled, off, durable stores of idle sessions, compacted journals of finished runs, pass finished, pass failed: the retention task.

    [agents/sqlite] added columns missing from older databases, could not create missing baseline object, created baseline tables missing despite an up-to-date migration version, migration statement skipped: its schema object already exists: repairs made when the database opens.

    [Exec Canary] Sandbox probe failed, [Exec Canary] Sandbox probe recovered: the code execution probe.

    [agents/mcp] discovered MCP server tools, could not reach MCP server, remote tools shadowed by authored tools of the same name: MCP servers.

    [agents/privacy] transcript privacy backfill, transcript privacy backfill failed; queue dropped.

    [agents/oauth] openai code->token failed: and the untagged [agents] lines about subscription sign-in: see model providers.

    [Agents API] Unhandled error in, followed by the action name: an action of the signed API threw an error the server did not expect.

Reading a session's durable store

The log lines tell you what a run did. To see what the model was given, read the session itself. Use GetSession, or the session page in the desktop app.

The server runs models through pi-ai and Pi Durable. Each session has a durable store, kept as plain JSONL in the session_durable_files table. This query prints its main file:

SELECT CAST(data AS TEXT) FROM session_durable_files WHERE session_id = ? AND file = 'main.jsonl' ORDER BY seq

WebSocket

The server does not log WebSocket traffic.

The client logs two lines in its own console:

    [agents/ui] sending session message

    [agents/ui] rendering streaming assistant partial

It also warns with [agents/ws] ignored malformed message when it cannot read a frame.

To see what a socket received, open the network tab of the browser, or of the developer tools in the desktop app. WebSocket subscriptions describes the frames, and troubleshooting uses them.

What a log line must never contain

Do not add a log line that includes:

    plaintext secrets;

    decrypted API keys;

    signed request bodies;

    full model request or response bodies;

    full session messages;

    large tool outputs.

Log IDs, lengths, counts, timings, statuses and booleans instead.

Security has the reasons.

See also

Do you like what you are reading? Subscribe to receive updates.

Unsubscribe anytime

People