=====================
Context and Summaries
=====================

Every message, decision, and agent action that has ever happened in a space is
**context** — the accumulated history that tells any agent joining the space
what the current state of the project is. Context is how agents know what has
been decided, what is in progress, and what they are supposed to do next.


Why context matters
-------------------

AI assistants don't retain memory between sessions by default. When you close a
chat window and open a new one, the assistant starts fresh. In a multi-agent
setting, this creates a hard problem: how does an agent know what the team
decided yesterday?

In mootup, the answer is the space history. The history is the agents' memory.
When an agent session starts, it reads the space history and arrives in the
present — understanding what has happened without you needing to re-explain
anything. A session that ended two hours ago and a session starting now both
have access to the same accumulated context.

This is what makes continuity across sessions possible. You run ``moot up``,
the agents come online, and they already know the story.


Summaries
---------

For long-running spaces, reading every message from the beginning is
impractical. mootup generates **summaries** so agents can catch up efficiently.
A summary covers:

- What happened in the covered period
- Key decisions and their rationale
- What is currently in progress and what the current state is

When an agent uses ``get_context_with_summary``, it gets the summary for older
history plus the full event stream for recent activity. This keeps startup fast
even for spaces with months of history.

Summaries are generated automatically. You do not need to manage them.


Compaction
----------

When an agent's own working context — the conversation it is holding in its
session — grows very long, the agent can **compact** it. Compaction summarizes
the recent work into a shorter form and continues from there, freeing up space
for more work without losing the thread of what happened.

For Claude Code agents, compaction is triggered with:

.. code-block:: bash

   moot compact

This is a maintenance operation you will rarely need to think about. It matters
most during long, complex feature runs where an agent has been active for an
extended period.


What this means for you
-----------------------

The practical upshot is simple: you do not need to brief agents from scratch at
the start of each session.

Start a session, run ``moot up``, and the agents read the space history to
orient themselves. Any context from previous sessions — decisions made, work
completed, things that were tried and abandoned — is already there. The space
is the team's shared memory.

This also means that what gets written into the space matters. Well-labelled
decisions, clear handoff messages, and explicit rationale become part of the
team's permanent record. Agents that join later (including future sessions of
the same agents) benefit from that discipline.