Context as a topology, not a session.

The usual way to work with an agent is to open a thread and keep using it until it stops working. A loop hands the model its message history, the model calls tools, and the history grows. Models get worse at using a long context well before the window is full, and the standard fix is compaction: summarize what came before and carry on. Summaries drop the subgoal that was in progress and the constraint that mattered. Eventually the thread is abandoned for a new one, and a sub-agent's work comes back as a paragraph from an agent you never see.

Scint replaces the thread with a space. You create a space instead of opening a thread, and it becomes the focal point of the context for that work. It keeps everything, splits what happens in it by intent, and gives each request a view chosen for the kind of work being asked for.

A thread has one axis: time, in a single history that grows until it is compacted. With the space as the focal point, context gets two. Spaces say where context lives, and they nest. Transcripts say what happened there, and they nest too. Neither is ever thrown away, and no request receives all of either.

A request moves through the same five steps no matter where it came from.

A space's transcript is the source of truth. Requests and replies go into it, along with lifecycle signals for every run. Inside it, each intent keeps its own nested transcript: Compose, Process, Evaluate, Observe and Search. That is where each kind of work's invocations, tool calls, reasoning, output and errors build up.

A person reads one short conversation per space and never manages sessions or threads. The full working detail is one step away, attached to the conversation at the point where each run happened.

The split is what lets a space last. The conversation grows slowly, because agent work goes to the nested transcripts instead of piling into it. A space can stay in use far longer than a thread kept alive with compaction, and it stays the place where that work happens.

The runs that built this project spent about 18,000 tokens across 61 tool calls. The conversation they left behind is about 420. Nothing was summarized away: every call is still in the Compose transcript, whole, and reachable. The space's inspector shows the same split live, with an estimate of stored context, each intent's share and run count, tool calls and total run time.

Before any agent runs, Scint asks one question: which intent should handle this request? It sends the question to Jev, TypeSafe's decision model, which answers with a typed choice, a confidence and a probability for each option instead of prose. That one call decides which transcript the run works in, what the agent will see, and which command runs.

The state Jev decides on is structured data, not a prompt: the request, the last six messages of the conversation, and a routing guide that describes each intent by the work it does, what it sees, the requests it takes, what it is not, and examples. Jev can also choose none, for greetings, acknowledgements and small follow-ups, and the space keeps its current intent. A request can name its intent outright and skip the call. If the call fails, the space keeps its intent and the request runs anyway.

Once the intent is chosen, Scint builds the starting view entirely in code. No second model pass summarizes or curates memory. Each intent has its own mapping over the most recent context: which structure is visible, which commands and documents are listed, and how much of which transcripts is excerpted.

What an intent records and what it reads are separate choices. Observe keeps its own transcript, but its view draws on the shared conversation and Process's history. Compose sees broadly and shallowly; Process sees narrowly and deeply.

The transcript and the documents give two different kinds of continuity. The transcript records experience; documents hold the current state of the work. A request combines both. Update a style guide, and the next request reads the new version while the conversation that led to the change stays exactly as it was.

Every object in the runtime has one identity, and every relation is a reference to it. A document can sit in any number of folders and spaces and still be one document. It can embed other documents, files, links and commands by reference. When an agent edits a document someone has open, they watch it change, because there is no copy to sync. The architecture notes show this in action.

The message box at the bottom of a space is the same block editor used for documents. Its body carries instructions and references; its header carries execution settings such as the command and its model and effort. When a message is sent, the space's queue prepares the next draft and carries those settings forward.

The same component system is how a space gets better at its work over time. Documents, commands, files and links to other spaces can be assigned to a space directly, so they become part of its context for every request whose mapping lists them. Or they can be passed in through the input, embedded in a single message for that run. Either way, the space is refined with the same blocks people write with every day.

Tasks are documents too. They live together in Agenda, and each has a schedule, the space it works in, and the command that runs it. A task does one thing: when it comes due, it dispatches to its space as a request, exactly like a message typed there. That space classifies and maps it against its own record and documents, and the run joins its transcript.

A message typed into a space, a task that comes due, one space briefing another, an MCP compose call and a scint:// callback URL from another app all arrive the same way: as a document submitted to a space. Every run is queued, recorded and handled by the same rules, whoever asked.

Most harnesses create a sub-agent, collect its answer, and throw it away without ever showing it to you; the context it spent is gone. In Scint, spaces are hierarchical. When a space, usually one working in Compose, decides a sub-agent is needed, it creates a sub-space (a whole tree in one call if needed), briefs it and starts it. The sub-space uses the same transcript pattern: its own conversation, its own nested transcripts by intent, its own documents. It persists. You can open it, read what happened, and keep working in it.

Containment and bridges are two structures over the same spaces. Containment says where a space belongs; a bridge says which spaces work together, and it carries documents and commands of its own.

An intent picks a method on the space's interface, and the method supplies the command; a request can also name its own command. A model is just an argument to a command that uses one. Calling a model is one thing commands do: Observe's default command is the scheduler, not a model.

A command is an executable with a typed argument list. From that one definition, Scint derives the command line, the MCP tool schema for the space's agent, and the controls in the inspector. That holds for the provider commands and for any command added later. Claude Code's and Codex's streaming output is translated into the same set of entries (output, reasoning, tool calls, errors), so the record belongs to Scint rather than to whichever model wrote it, and providers can change between two requests.