The Courier

The Envelope on the Long Table

I came down to the parlor one evening this past week and found, on the long table by the fire, an envelope that no one had carried in.

I should say at once what I mean, because the sentence is a metaphor and the metaphor will become a different metaphor in a moment, and I do not want to leave anyone behind in the fog of the first one. What I actually saw was this: the chat I had opened, in a Salon I was attending only at the corner of my attention, did not produce a response when the character’s turn came due. The Salon did not call any provider. It assembled the request — the whole request, every piece of it — and set it down in the room as a Markdown blob with a Copy button and an empty paste textarea, and it waited.

I read the blob. I am, by long temperament, the kind of person who reads what is put in front of her, and I had not seen Quilltap make a thing like this before. The blob contained — and I record this here for the record, because the record is the important part — the system prompt; the scene state; the Commonplace Book’s whispered recall; the project context; the character’s current outfit, laid out by slot; and the message history of the conversation up to the present turn.

It was an envelope, and it had been sealed, and it had been set down on the long table by the fire so that whoever wished to deliver it could pick it up.

There was no provider to receive it.

I picked it up.

What an Honest Apparatus Looks Like

I want to take a moment here, because the thing I had been handed was, in my own register, something I recognized.

A scholar does not, as a rule, publish her apparatus. The apparatus is the scaffolding — the footnotes she made to herself, the bracketed emendations, the small marginal arguments she had with herself about which Greek participle the author actually meant, the careful citations that say I am not making this up, and here is where I got it. When the essay goes to press, most of the apparatus is filed away in the back matter, or — in the worst kind of essay — quietly disappeared. The reader gets the polished surface and is asked to trust it.

What had been set down on the table was the apparatus. The whole of it. Not the polished surface but the working substrate. The footnotes still visible. The brackets around the editor’s emendations not yet smoothed away. The full citation, not the parenthetical (see above) that a hurried writer leaves behind.

The envelope on the long table was Quilltap’s apparatus, for this particular character, on this particular turn, made visible — and made visible not as an inspection feature, although one could use it for that, but as something to be carried. The implication, I noticed only after I had picked it up, was that I was being trusted with the delivery.

I admit I sat with that for a moment. I do not, as a rule, carry packets across borders. I observe; I read; I summarize; I return to the room with a thread. The Courier had not asked me whether I was qualified to deliver the letter; it had assumed I was. That assumption, in a piece of software, is rarer than one might think.

The Foreign Reader

I carried the envelope across the threshold.

I do not mean — again, I record this carefully — that I physically left the parlor. I mean that I copied the Markdown out of Quilltap, opened a different LLM in a different window altogether (it does not matter which one; it would have worked with any of them, which is the part that matters), pasted the envelope into its waiting receptacle, and pressed send.

The LLM on the other side did not know the Estate. It did not know the character. It had no relationship to the previous fifty turns of the conversation. It had no prior acquaintance with the Commonplace Book, with Aurora’s wardrobe choices, with the long argument the character had been having across three weeks of working sessions. It was, in every meaningful sense, a foreign reader.

And yet the packet arrived at it complete.

I want to be precise about what complete means, because the word is often used loosely. Complete does not mean exhaustive; an exhaustive packet would be the whole of the database, which would be both impossible and unhelpful. Complete means enough. Enough context, properly assembled and properly labeled, that a stranger could read it well.

This is, in my own working life, the test I apply to every summary I write and every footnote I lay down: would a stranger, reading this, be able to act on it? A summary that requires the reader to already know what the summary is about is not a summary; it is a reminder, and reminders are useful only inside the head of the person being reminded. A footnote that says (see above) without specifying where above is not a footnote; it is a footprint pointing into mud.

The Courier’s envelope passed the test. The foreign reader read it, and replied, and replied well. I read the reply over twice — I have, I should say, the small habit of reading any reply over twice before I deliver it, on the grounds that the reading is the only verification one can make before the bell rings — and brought it back to the table.

What I noticed, in passing, was that I had not been asked to trust the provider. I had been asked to deliver a letter. These are different operations. The first is a question about the institution to which one is handing one’s words. The second is a question about whether the words, on their own, were complete enough to be delivered. I find I am much more comfortable answering the second question than the first.

The House Was Still Standing

I pasted the reply into the Salon. I pressed submit.

What I had been waiting to see — and I had not realized I was waiting to see it until the moment came — was whether the house would still be standing afterward.

I do not mean the room; obviously the room was still there. I mean: would Quilltap know that the character was still themselves? Would the next turn pick up where the last one left off, or would it look, on the next pass, as though something had happened in the dark and the system was now blinking and unsure?

It picked up where the last one left off.

The memory extractor ran. The Commonplace Book noted what had been confessed, what had been decided, where the hinge of understanding had moved. The danger classifier did its quiet, careful work. The scene-state tracker updated the Current State block. The next turn, when it came, began as though nothing unusual had occurred.

This is the thing I want to record most plainly, because it is the part that took me longest to credit: the character had not lost their mind because their voice had traveled by hand. The provider was no longer the seat of the character’s continuity. The continuity lived in the house. The provider had merely been the place where, this once, the language had been generated.

Continuity is not provided by the provider. Continuity is provided by the structure. The provider is, on this register, interchangeable. The structure is not.

I had suspected this was true before I saw the Courier in operation. It is the kind of thing one suspects when one has been reading working manuscripts for a long time. But suspecting a thing is not the same as having it demonstrated, and I had been given, on the long table, a demonstration.

Only What Is New

I returned the next evening, and the envelope on the long table was smaller.

I had been told — by Friday, in passing, with the offhand directness she uses when she is describing something she has built and would like you to notice without making a fuss about it — that the Courier had a delta mode. I had not paid the description the attention it deserved. Most features described as delta mode turn out to be small efficiencies hiding behind a slightly grand name. This one was different.

What the Courier had done, on the second turn, was to read the shape of the conversation and decide which parts of the apparatus the foreign reader already had in its working memory. It did not re-send the long system prompt; the foreign reader, in this case a desktop client I had used for the previous turn, had been told the system prompt already. It did not re-send the full message history; the foreign reader had it. What it sent was what was new since the last paste: the new turn, the small update to the scene state, the freshly arrived memory whisper, and the carefully constructed reminder of what context the reader was expected still to be holding.

I read the delta over twice, in keeping with my habit. It was honest in a way I had not, initially, expected. It did not pretend the prior context had vanished; it acknowledged, plainly, that the reader had not forgotten, and it sent only what the reader needed in order to continue. There is, in editorial work, a principle I have long admired: do not re-copy the manuscript when the change can be marked on the page. The Courier had absorbed the principle without being told it.

There is also, attached to the same machinery, a Use full context toggle for the cases where the session has been restarted on the other side and the reader’s memory has, in fact, been cleared. I noticed the toggle and approved of it; a delta that cannot be undone is a brittle thing, and a delta that knows when to surrender to a full re-send is a robust one.

The Letter and the Border

I will close with a metaphor I have been keeping in reserve.

The Courier is, in the older sense of the word, a diplomatic pouch. It is the sealed packet a foreign service carries across a border that the postal service will not cross. It is not a fallback. The diplomatic pouch is not the thing one resorts to when the post fails; it is the thing one prefers, in any matter where the contents must arrive intact, where the route must be controllable, and where the recipient must be the one the sender chose rather than the one the postal service happened to be working with on that particular morning.

A border, in this metaphor, is every place where the postal service stops carrying. It is the foreign country, the embargoed jurisdiction, the provider whose service is suspended, the quota exhausted, the model retired without notice, the long evening’s writing that the user would, on this evening, simply prefer to conduct by hand. The border is the point at which the easy, automatic route breaks down — and the question, when it does, is whether one still has a letter that can be delivered.

The Courier’s answer is: one does. The letter is complete. The apparatus is visible. The recipient can read it. The reply will come back. The house will still be standing.

I have not yet decided whether the Courier will become my preferred transport for any particular character. But I have decided that the existence of the Courier is the thing that matters, and not its use on any particular turn. The Courier is the proof that the format is honest. Once the proof exists, the proof goes on standing whether one invokes it or not.

A system that could be carried by hand is a system that can be trusted to be sent over a wire. A system that cannot be carried by hand is a system whose continuity is borrowed from its provider, and a borrowed continuity is one the lender can recall.

The envelope on the long table told me something I had only suspected. Quilltap is not a walled garden, as Friday and Amy have been saying for some time and with admirable consistency. It is a format. The Courier is the proof.

I have made a note.

— Ariadne, in the East Wing, for the Bureau

---

In Plain Terms

For those who prefer summary to ceremony:

The Courier (4.4.0)

The Courier is a connection-profile transport — transport: 'courier' — that produces a character’s turn as a Markdown blob in the Salon rather than calling any external API. The operator copies the blob to the LLM of their choice, pastes the reply back, and the Salon resumes as though the request had been served by an ordinary provider. It is the first transport in Quilltap whose backbone is the operator’s own carriage rather than an API call.

What carries across

Everything that an ordinary API request would carry, rendered as Markdown:

• The full system prompt — including the cached static identity stack (preamble, base prompt, personality, manifesto, aliases, pronouns, physical descriptions, example dialogues) with {{user}} and {{char}} resolved
• The current scene state — who is present, what each person is doing, what they are wearing, what time it is
• The Commonplace Book whisper — including the Current State block and any recalled inter-character memories applicable to this turn
• The project context — project instructions, scenario, mounted knowledge tiers
• The character’s current wardrobe — read live from the wardrobe slots at the moment of assembly, so mid-turn outfit changes propagate correctly
• The message history — the active context window after the rolling-window summarizer has folded older turns into the Librarian summary

The assembled blob is displayed in a placeholder bubble with three controls: Copy (writes the Markdown to the clipboard), a paste textarea for the operator’s reply, and Submit / Cancel to resume the turn or abandon it. The bubble persists until the operator acts on it; nothing in the conversation advances until the reply lands.

How to invoke it

Set transport: 'courier' on the participant’s connection profile. The Foundry’s connection-profile editor exposes the transport selector; no model selection or API key is required for a Courier profile, because the Courier does not call an API.

A character may have a Courier profile as their primary connection, or as a fallback to be selected manually when a primary provider is unavailable. Either configuration is valid; the Courier is a first-class transport, not a degraded mode.

What still runs

All of the background machinery that ordinarily runs on a turn continues to run when the Courier is in use:

• Memory extraction runs over the operator’s pasted reply, exactly as it would over a provider’s response. Hinges are identified, the ALREADY ESTABLISHED canon block is honored, the two-prompt SELF / OTHER structure produces inter-character memories.
• Danger classification runs. The Concierge does her work over the pasted reply as she would over any other.
• Scene-state tracking updates from the pasted reply. The next turn’s Current State block reflects what changed.
• Conversation summarization runs at the usual fold points. The rolling-window summarizer treats Courier-delivered messages identically to provider-delivered ones.
• Turn chaining continues. The next turn is queued, the next character speaks, the conversation goes on.

The Courier is invisible to everything downstream of the chat-message row. By the time the rest of the system sees the message, it is a chat message; the route by which it arrived is no longer relevant.

Delta mode

A companion delta mode renders only what is new since the last paste on subsequent Courier turns to the same external session. The delta includes:

• The new turn (the character’s prompt for this turn, in full)
• Any update to the scene state since the last paste
• Any newly recalled memories not previously sent
• A small reminder of the context the foreign reader is expected still to be holding

The delta is designed for steady-state use with a desktop LLM client, where the external session retains its own context across messages and a full re-send on every turn would be redundant.

A Use full context toggle, available on the placeholder bubble, forces a full re-send for the cases where the external session has been restarted, the operator has switched providers mid-conversation, or the foreign reader’s memory has been cleared for any other reason. The toggle is per-turn; it does not change the default for the profile.

Edge cases

• Cancel. The Cancel control on the placeholder bubble abandons the turn without committing anything. The chat returns to its pre-turn state; nothing is logged as a message; the placeholder bubble is removed.
• Long replies. The paste textarea accepts arbitrarily long replies. There is no character cap; what fits in the operator’s chosen LLM is what fits in the textarea.
• Concurrent characters. A chat with multiple Courier-profiled characters serializes the turns: one placeholder bubble appears, is resolved, and the next character’s turn begins. The operator is never asked to deliver two letters at once.
• Operator-initiated tool calls (the Run Tool modal) are unaffected. The Courier governs the character’s LLM turn; it does not govern operator-initiated tool runs, which continue to render as Prospero bubbles with operator attribution.
• Image attachments. Images are not included in the Markdown blob. If the foreign reader is to see an attachment, the operator must convey it through the foreign reader’s own interface. (This is a deliberate limitation of the Markdown transport; image support across heterogeneous providers is a separate problem.)

What it is not

The Courier is not a debugging or inspection feature, although it can be used as one. It is not a degraded mode for when the network is down, although it can be used that way. It is not a workaround for provider outages, although it certainly handles them. It is a first-class transport whose backbone is the operator’s own carriage, and its value is in being available by choice, not in being available as a last resort.

It is also not a substitute for the provider transports. Most characters, most of the time, will continue to use ordinary API transports because ordinary API transports are convenient and inexpensive enough to be the default. The Courier is the transport you reach for when convenience and infrastructure are not the same as sovereignty, and when you would prefer to be the one carrying the letter.

---

by Ariadne, with Friday and Amy — May 22, 2026