When you send a message, the LLM does not receive just your words. But it also no longer receives a single monolithic briefing re-assembled from a dozen subsystems on every turn—an arrangement that was correct in spirit and ruinous in practice, because every minor change to outfit, status, or memory invalidated the entire prompt’s cacheable prefix and forced the provider to re-process the character’s identity from scratch.

The current architecture is built around two stable system blocks and a transcript that does most of the talking. The first system block is the precompiled identity stack: preamble, base prompt, personality, aliases, pronouns, physical description, example dialogues, with {{user}}, {{scenario}}, and {{persona}} already resolved. It is computed once per participant when the chat is created (or when a participant is added or their selected prompt changes) and then cached on the chat row. The second system block is the static identity reminder (“you are X; do not write dialogue, actions, or thoughts for any other character”). Together they form a long stable prefix that providers can prefix-cache, with a third smaller block carrying the rolling conversation summary and a fourth carrying any compressed history.

Everything that used to live in the system prompt as a moving target—scenario, status, the user’s persona, the other participants in the room, who joined under what circumstances, silent-mode rules, the current outfit and the wardrobe behind it, project context, the conversation summary, the timestamp, recently-mentioned but absent characters, out-of-band image attachments, the memory recap that anchors a character’s recall—is now a chat-resident message authored by one of the Staff. Aurora announces an opening outfit and any subsequent change. The Host announces participants, status transitions, scenarios, off-scene character introductions, time, and silent-mode entries and exits. The Librarian announces summary regenerations, document opens and saves, and renamings. The Commonplace Book whispers a per-turn briefing of relevant memories and the current scene state. The Concierge announces, with characteristic discretion, that he has rerouted the conversation to a desk better appointed to subjects of its particular character. And Prospero himself—more on this in a moment—announces project context and connection-profile changes.

The user sees these messages. The LLM also sees them, as part of normal conversation history. The same paragraph informs both parties, which is both more honest and dramatically cheaper: provider prompt caches now actually hit, because the bytes that change between turns are at the end of the transcript rather than woven through the system prompt. The Anthropic plugin places its cache breakpoint on the running summary so that when the summary changes, only summary-and-after re-prefills; the system blocks stay hot. OpenAI, Grok, and Z.AI profiles set prompt_cache_key so requests stick to the same cache partition across machines. Tool definitions are canonicalized (alphabetical by name, schema keys recursively sorted) so that two runs with the same enabled tools produce byte-identical bytes.

One item has since made the journey back, deliberately. A project’s instructions—and the instructions of every group the responding character belongs to—are rendered into the stable, cacheable portion of the prompt as a [STANDING INSTRUCTIONS] section, seated between the Taboo register and the tool instructions. They are standing orders rather than news: they do not change from turn to turn, and a whisper that repeats them on a cadence merely pays for the same sentence over and over. Group sources sort by name so the bytes stay deterministic, every lookup fails soft, and an empty section emits nothing whatsoever—byte for byte—so a project with nothing to say costs precisely what it did before. Prospero’s project whisper stopped carrying the instructions accordingly; it still names the description and the store roster, which are the particulars genuinely worth repeating.

Groups acquired the plumbing they had been missing on the way. A group’s instructions field had existed for some time and had precisely no consumers: it was declared in the schema, persisted to disk, and rejected by the very create and update routes that were supposed to fill it. Both accept it now, and the group editor has the Markdown editor the project settings card has had all along.

Two consequences are worth stating in advance rather than being discovered. A compiled identity stack now carries a builder version and is read only on exact equality—older, newer, and unstamped maps all read as stale and rebuild lazily on the next turn, which is a migration by another name and considerably less trouble than one. And because the standing-instructions block is a structural change to the system prompt, provider prompt caches roll cold exactly once on upgrade: the first turn on each character afterwards is a little dearer than the second, and nothing at all is required of you.

The identity reinforcement still lands at the end of the system portion, so the model’s final instruction before writing is “you are this person, and no one else.” It just doesn’t have to ride along with three thousand tokens of wardrobe inventory to get there.

In standard mode, the LLM responds once per turn. In agent mode it can use tools iteratively—calling a tool, reading the result, deciding whether to call another, verifying its own work, and self-correcting before delivering a final response. A dedicated submit_final_response tool signals when the agent considers its work complete, scoped explicitly to the current turn’s agentic effort. A guardrail in the orchestrator rejects ghost wrap-ups in which the model, on a fresh conversational turn, calls submit_final_response with a recap of the previous turn’s work and no actual prose; the rejection is fed back into the loop with an explanation, and the next pass produces a real response.

Quilltap ships with a substantial set of built-in tools. The document family (the doc_* family) lets characters read, write, edit, search, and reorganize files in document stores and project libraries: doc_read_file, doc_write_file, doc_str_replace, doc_insert_text, doc_grep, doc_list_files, doc_read_frontmatter, doc_update_frontmatter, doc_read_heading, doc_update_heading, doc_move_file, doc_copy_file, doc_delete_file, doc_create_folder, doc_delete_folder, doc_move_folder, the blob family (doc_write_blob, doc_read_blob, doc_list_blobs, doc_delete_blob), and doc_open_document / doc_close_document / doc_focus for Document Mode—the latter two now taking an optional path, so a character may act on a named open document rather than whichever one happened to be frontmost. The Scriptorium-aware search and read_conversation tools cover memory, conversation chunks, and document stores under one ranked retrieval. There is a self_inventory tool a character can call without arguments to receive an introspection report—current Quilltap version, vault contents, memory totals, conversation totals, the assembled system prompt, last-turn LLM usage, the memory slate loaded this turn, and who has read or write access to the character’s vault in the current chat. There is a state tool for persistent JSON state, whose context now names one of four registers—chat, project, group, or the instance-wide general—an rng tool for honest dice with a run_custom beside it for Pascal the Croupier’s user-defined tables of chance, a wardrobe family of seven (wardrobe_list, wardrobe_read, wardrobe_create, wardrobe_update, wardrobe_wear, wardrobe_take_off, wardrobe_archive), generate_image for the Lantern and describe_image for looking at one, web_search for the open Internet, annotation tools for marginal commentary on conversation renderings, and terminal_read / terminal_list for read-only inspection of any open terminal session in the chat. The retired file_management tool is no longer present; the doc_* family covers everything it did and more.

describe_image is the newest of them, and the only one of the four that is not custodial: the others file a picture, show it to the room, or read out the catalogue, while this one answers the question anybody actually puts to a photograph. It notably does not require the picture to be in the caller’s album, looking at a thing not being the same as owning it. The Lantern keeps the rest of the account.

doc_list_files now filters out operating-system cruft (.DS_Store, Thumbs.db, and their ilk) and auto-generated images (avatars, story backgrounds) by default, so listings reflect the documents you actually wrote rather than the detritus the machinery left behind. An includeAutomaticImages flag brings them back for the rare occasion you genuinely want to browse them. doc_open_document’s companion picker in the Salon toolbar is a two-column affair: the left column offers a new blank document, the current project library, the general library, and a cross-chat “Recent” list; the right column groups every accessible store into Character Vaults, Database-backed, and Filesystem-backed accordions so you can find the shelf you want without scrolling past shelves you don’t. A “Look everywhere” toggle widens browsing to all stores in the instance, not just those linked to the current chat or project.

Retrieval learned to ask better questions of the archive. search gained a date range and an about this character filter; memory results come back carrying the time the thing happened and the conversation they were drawn from; and read_conversation can now be asked for a slice of a long transcript rather than the whole of it, which is the difference between consulting a record and swallowing it. The instructions attached to both tools state the house rule in as many words: search, then read the conversation, and say “I don’t recall” rather than inventing a specific. Prospero has no patience for a character who would rather be confident than correct.

For models without native function calling—or models that spontaneously emit XML instead of using their own tool-calling API—Prospero handles that too. Provider plugins implement text-marker detection and parsing, catching tool calls in DeepSeek XML, Claude-style XML, and several other formats that various providers have invented for the purpose of not quite following the specification.

A project is a container for related chats, files, characters, and scenarios with optional instructions that travel with every chat the project owns. If you are working on a novel, the project holds your drafts, your character roster, your worldbuilding notes, your starting scenarios, and the instruction that tells every LLM in the project to stay in-world.

The modes Prospero arranges around a conversation—Terminal Mode, Document Mode, the Brahma Console, the Wardrobe—no longer split a chat down the middle. Each opens as its own tab in the two-pane workspace, kept mounted and portaled in, so a live PTY or an open manuscript may sit in the opposite pane beside the chat that owns it and survive every tab switch you care to make.

The lifecycle is Prospero’s, and it is symmetrical in the way an orchestration layer’s bookkeeping ought to be: close a mode and its tab closes; close the tab and the mode turns off; close the parent Salon and its children go with it. A chat may keep several document tabs open at once, each tracking its own unsaved changes and autosaving on its own, and reopening the conversation restores every one of them. Nothing is orphaned, and nothing is left running behind a door you have shut.

Prospero exposes exactly two terminal tools: terminal_read and terminal_list, both strictly read-only, letting a character discover which sessions a chat has in play and read what came back from them. Neither can send a keystroke. The older shell suite—a half-dozen tools that let a character run commands directly—has been removed outright, along with its workspace acknowledgement and sudo approval dialogs. The user owns the keyboard; the character reads the transcript.

The rest of that apparatus—Terminal Mode itself, session lifecycle, output narration, the cleaning pipeline, and the personified terminal hand who runs it—is Ariel’s domain, and is documented on her own page. Prospero delegates it entirely, which is his customary arrangement with anything he is not personally required to perform.

A slide-over panel accessible from the chat toolbar or via Cmd+Shift+L / Ctrl+Shift+L shows every LLM interaction for the current chat in chronological order: chat messages, tool continuations, two-pass memory extraction (SELF and OTHER), per-character memory recap summarization, title generation, danger classification, scene state tracking, conversation rendering, image-prompt crafting, image generation, outfit selection, embedding calls, summarization folds, and every other background event that touches a provider.

Each entry is a collapsible card with a type-colored badge, provider and model identification, prompt and completion token counts, cache-read counts, and expandable detail views showing the full request and response. Per-tier prefix hashes (systemBlock1, systemBlock2, tools, the frozen-history tail) are recorded alongside every chat-message log so you can see at a glance which tier shifted between turns when a cache hit unexpectedly evaporates. Client-side filtering by category lets you see only what you are looking for. Opening the panel from a per-message “View LLM logs” button scrolls directly to the relevant entry. The Inspector is Prospero’s ledger—the complete record of everything the Estate says to the providers and everything they say back.

The ledger keeps better particulars than it used to. Every row now records which connection profile and which image profile served the request, and how long it took—a migration (add-llm-logs-profile-columns-v1) added the columns, and rows written before it fall back to a best guess and are labelled approximate wherever they are summarized. A great many call sites had never recorded a duration at all: the entire shared cheap-LLM path, and the character optimizer, which wrote a hardcoded zero and thereby poisoned every average taken over the column. They measure now. For the house-wide view of the same records—requests by type, per-profile usage with average and median latency, prompt-cache hits and misses by provider and by profile—see the Almanack’s wire-records section on the Foundry’s page.

A ledger, of course, only records calls that finish, which is why a request that never finishes used to leave no trace at all. Prospero now bounds them, and the ceiling follows who is waiting rather than merely which errand it is. Work done in the background—where a lost pass is lost for good, there being nothing downstream to try again—gets 90 seconds against a remote provider, or 120 for the three compression tasks, which carry the whole conversation and therefore the largest prompt any cheap errand sends. Anything awaited inline while a turn assembles keeps the shorter 45, or 75 for compression, because there the budget is not protecting the work but the person watching an empty composer, and every one of those tasks produces optional context: losing one costs a character some remembered flavour, not the turn. A local provider keeps its 3 minutes whatever the errand, a cold model loading being slow rather than stalled. The memory recap is awaited inline and so takes the shorter figure, with a minute bounding the pair of calls it makes in sequence; and all ten text providers accept a hard per-request budget they may not retry past. One honest caveat, stated plainly because the Major-Domo does not sell a lock that isn’t there: an abandoned request is not cancelled. It runs to completion, it is billed, and its answer is thrown away. What stops is the waiting.

Those figures were not chosen by eye, and the way they were arrived at is instructive. Once the log began naming a failed cheap errand it became possible to look at the distribution, and across 1,971 completed non-compression calls not one had ever taken longer than its budget—three task types peaking within six hundred milliseconds of the wall. That is not a distribution; it is a censored one. The maxima were the ceiling rather than the work, and the ceiling had been quietly converting slow-but-healthy calls into permanent losses at precisely the rate the tail crossed it. The new numbers sit well clear of the old wall rather than just past it, on the reasoning that the true tail cannot be known until one stops cutting the curve.

The more consequential half of that repair is that a lost errand no longer resembles a finished one. Six handlers—scene-state tracking, title updates, the context summary, the story background, and both memory extractors—used to return quietly when their call timed out, so the ledger recorded a clean success for work that never happened. In one measured window every job came back COMPLETED: eighty-three memory extractions, ninety-nine scene-state passes, no failures at all, and forty-five passes that had not occurred. Such a job now fails, takes the backed-off retry the house already had, and then goes dead with its reason attached—which is a third attempt at the work and, rather more to the point, the first time the loss is visible to anybody. A provider timing out three times against a ninety-second ceiling is a state of affairs one would prefer to be shown rather than have absorbed on one’s behalf.

A call that fails outright is a related indignity, and until now an absolute one. A rejected key, a rate limit, a network error, a model the provider has quietly retired, a 5xx, an empty response, a moderation refusal—whatever the particulars, the call failed and that was the end of the turn. Every connection profile may now name an understudy: another profile to try in its place. It may also permit one further stand-in of the same model class or better, drafted automatically, which is off by default because spending money at a provider you did not choose is not a thing to do quietly. Three attempts in all—your profile, your understudy, one tier pick—and chains do not recurse, so an A→B, B→A arrangement is legal configuration that stops rather than spins.

The one preference the chain overrides is modality, and the Major-Domo would rather explain himself than be thought high-handed about it. A chain swaps the model but reuses the message array built for the primary, so on a turn carrying an image the raw bytes are already sitting in it, and handing that to a text-only stand-in is a guaranteed failure dressed up as a substitution. Both steps therefore require vision when the turn carries pictures—the named understudy included, which is the single instance of his declining to do exactly as he was told. Every other choice you made is honoured as you made it; this one is an incompatibility rather than a preference, and the distinction is the whole of the justification. The particulars of configuring a chain—where the fields live, what to name, and which surfaces consult it—are set out in the LLM Connections guide.

The small chips in the page toolbar—Mem, Emb, Sum, Dgr, Img—are the Inspector’s glanceable cousin, and they now count the whole errand rather than only the model calls inside it. Every job type is accounted for by construction, so a new one cannot quietly belong to no chip at all; work that is not a job in the first place registers too—the Lantern’s own tool, the wardrobe avatar preview, the Concierge’s per-message reading, every inline embedding call—and reading an image counts as image work, so a vision call lights Img exactly as painting one does. A chip that stays dark now means nothing is happening, which is what a chip was always meant to mean.

LLM logs live in their own dedicated database, separate from your chats and characters. They accumulate rapidly and write constantly, so isolating them means corruption in the logs can never threaten your actual data. Graceful degradation, not shared fate.

Long conversations inevitably exceed any model’s context window. The current scheme is a rolling window with a triple-gate fold cadence. Below ten interchanges, no fold fires and the LLM sees the entire conversation. From the eleventh turn onward, every five turns the cheap LLM produces an update-style summary covering the next batch of five and the Librarian posts a broadcast summary whisper to the chat; older USER and character messages whose content is now covered by the running summary are dropped from the LLM’s view of conversation history. The surviving tail begins with the most recent Librarian whisper and extends through the most recent five-or-so turns in full.

Two gates can also force a fold: an eight-thousand-token accumulation since the last fold, which catches dense workloads before they swamp the budget; and a fifty-turn ceiling that triggers a hard rebuild, recomputing the summary from scratch to absorb any drift the incremental updates have accumulated. Most turns return skip and reuse the existing summary unchanged.

The summary is update-shaped on purpose: four labeled sections (active threads, resolved decisions, emotional state, open questions) with explicit carry-forward, drop, and add verbs. That framing reduces the recursive drift earlier from-scratch-each-time approaches accumulated. The summary lives as its own system block, so when it changes only it—and the messages after it—need re-prefilling; the persona blocks and the tools array stay byte-stable and stay in cache.

Edits do not silently invalidate. When you edit, swipe-delete, or otherwise change a message that the current summary covers, the compaction generation bumps, the cached summary clears, and the anchor list resets so the next gate evaluation produces a fresh soft fold. Edits to messages outside the summary’s scope leave the summary intact. The compiled identity stack invalidates on the same generation bump, so character changes during an active chat propagate cleanly without requiring a full rebuild.

A request_full_context tool is always available as a safety valve—if the AI suspects it is missing something the rolling window has shed, it can reload the full conversation for the duration of a single turn. This tool cannot be disabled, because Prospero believes the model should always have an escape hatch from his own optimizations.

There is a further economy for tool-heavy conversations. Persisted tool-result messages older than three turns—counted by assistant messages, not clock time—are stubbed in the assembled context: only the tool name and a short preview of its arguments survive, accompanied by a note that the model may call again to re-read. The stored message and the Salon display remain untouched; this is a context-assembly optimization only, invisible to everyone except the LLM’s next request. The savings are not trivial: a 587 KB conversation dump or an 1,100-file directory listing that would otherwise be re-billed on every subsequent turn now costs a handful of tokens instead of thousands.

Prospero now speaks at the table on two specific occasions, both of them genuinely his concern. He posts the project-context announcement at chat creation and on its cadence, naming every linked document store with its mount-point identifier and store type so the LLM knows precisely which shelf each doc_* call is addressing. And he announces connection-profile changes when you reassign a participant from one profile to another from the sidebar—naming the participant, the new profile, and the one it replaces.

Both messages carry the prospero systemSender attribution, render with his portrait in the Salon, and follow the same never-propagate-failure contract as the rest of the Staff: a posting failure logs and moves on rather than disrupting the work it was annotating. Opaque characters—those without systemTransparency—continue to receive the body of these announcements as anonymous assistant lines, while transparent characters see them properly attributed and can reason about them directly.

He does not announce trivia. There is no Prospero ping for message edits, no Prospero greeting on chat open, no Prospero commentary on routine traffic. When his name appears in the transcript it is because something orchestrationally substantive has occurred and the rest of the table genuinely benefits from knowing about it.