Session start

“Knows you, your brands, and what’s on your plate today” has to be true at the first message of every session, on every surface — chat, a scheduled run, an operator’s terminal. That is the job of the boot contract: a defined, lean bundle every agent loads when it wakes, and nothing else until a skill asks.

What loads

flowchart TB
  subgraph static["Static — fixed documents"]
    I["Identity & personality"]
    H["House rules"]
    U["Your profile"]
    E["Brand essence"]
  end
  subgraph live["Live — assembled by a program, scoped to you"]
    P["Open plate — tasks assigned to this agent"]
    F["Feedback waiting on it"]
    K["Top facts (a ranked digest)"]
    V["Recent events, noise filtered"]
    X["Automations that failed in the last 48 h"]
    S["Short narrative of what it was last doing"]
  end
  static --> B["One session bundle"]
  live --> B

Static documents are the same shape every session: who the agent is, how it behaves, the workspace’s working discipline, your profile and hard rules, and the brand’s one-page essence.

Live state cannot be a document, because it changes by the hour and has to be queried and filtered: the agent’s open tasks from the database, feedback flags on reviews it has not acted on, its most relevant facts, its recent events with routine noise dropped, any scheduled run of its own that failed recently, and a short narrative digest of its last stretch of work. A program assembles these into one bundle, scoped to you and this agent — private memory is included only when a principal is present; a scheduled run gets the plate and nothing private.

The bundle is small by design. It is paid on every conversation, so every line in it has to earn its place.

Two loaders, and why there are two

Static identity is read as fixed files. Live state is assembled by a program. They are separate because a file loader cannot run a query, slice a document, or filter events — and because a “read this file” instruction in an identity document silently never fires on a surface where the agent is handed a conversation without taking a startup turn. The program is the one loader that runs on every surface; that is what makes the first message of a chat, the first line of a scheduled run, and the first prompt in a terminal start from the same knowledge.

What waits

Everything not in the bundle is on-need:

Loads when…	Examples
A skill or flow declares it in its setup step	The brand’s customer language, a reference document, a strategy file
The agent follows a link from the essence	Deeper brand documents — products, lessons, positioning
A task explicitly needs it	Architecture references, the results ledger, a runbook

Each piece of context loads once per task. A flow’s setup declares what the whole arc needs; the skills it calls inherit it. Nothing is preloaded “in case”.

What a session writes

At the end of a task or session the agent records what should persist — decisions, durable facts, a status — through the sanctioned memory writers, scoped to you. A short wrap-up updates its narrative summary. Those writes are what the next session’s live bundle is built from. See Sharpening.

live The two-loader boot, the scoped live bundle on every surface, and the on-need discipline are live and verified against the running system.

Related

What your agent remembersThe five libraries the bundle draws from.

Your agentsIdentity, lanes, and the roster.

How agents runThe runtime the bundle is loaded into.

SkillsHow a skill declares what it needs.