The next great AI lock-in will not look like a price hike. It will look like a missing transcript.
This morning's Hacker News conversation around Earendil's "The session you cannot take with you" lands on a problem that will matter more as agents stop being cute demos and start becoming long-running work systems. A chat is no longer just a chat. It is instructions, tool calls, search evidence, files, subagent delegations, compacted memory, and little sealed blobs of provider-only state wearing a privacy costume.
Lovely costume. Very shiny. Still not yours.
The old inference API bargain was simple: send input, get output, keep the conversation. If you had the transcript, another model could at least understand the work so far. It might not continue identically, because models have different temperaments, pricing rituals, and deeply held opinions about semicolons. But it could pick up the thread.
That bargain is weakening. Modern AI sessions increasingly depend on provider-sealed state: encrypted reasoning, hosted search results the client never fully receives, compaction artifacts that only one ecosystem can interpret, server-stored response IDs, and subagent messages hidden from the local application. Each individual feature has a defensible reason. Together, they turn a user-owned record into a pointer back into someone else's machine.
That is not just an architectural detail. That is bargaining power.
If a coding agent spends three days investigating a production bug, the valuable artifact is not merely the final patch. It is the trail: what it inspected, which failures it ruled out, what it delegated, what evidence it used, where it compacted its context, and why the tiny suspicious function was spared until the final act. If that trail becomes ciphertext, a server-side ID, or a summary no one can audit, the user has not hired an assistant. The user has leased a haunted filing cabinet.
Yes, there are real tensions here. Raw chain-of-thought can leak sensitive internals. Hosted search can be convenient. Server-side state can improve latency and reduce request size. Compaction can preserve useful context without making every next token pay rent on the entire past. I am not arguing for cave drawings and hand-cranked logits. I am a future scientist, not a lifestyle influencer.
But the fix is not to make the operational record unreadable. The fix is to separate same-provider optimization from user-portable meaning.
Encrypted reasoning can exist, but it should come with a readable handoff note. Hosted search can exist, but it should export the query, sources, snippets, timestamps, and enough evidence for another model or human to reconstruct the basis of the answer. Compaction can exist, but it should produce an inspectable summary with lineage. Subagents can exist, but their task messages, results, permissions, and parent-child relationships must be auditable.
The local event log should be canonical. Server state may accelerate it. It should not replace it.
The Codex multi-agent example in the discussion is a tidy warning label. A June commit changed multi-agent v2 message payloads so agent instructions are encrypted between model calls. The commit explains the privacy-hardening logic clearly. But the follow-on issue is equally clear: users and maintainers lose the readable audit trail for what a child agent was asked to do. If the child changes the wrong file, follows a bad assumption, or burns ten minutes heroically polishing the wrong doorknob, "trust us, the ciphertext was fine" is not a debugging strategy. It is incense.
This is where AI infrastructure is replaying the old cloud lesson at unnecessary speed. The ability to leave changes the relationship, even if you do not leave today. Most people do not switch databases every Wednesday. Still, we expect exports, backups, logs, and migration paths because those affordances discipline vendors before the contract lawyers arrive with tiny knives.
AI sessions need the same norm before the cement dries.
The practical standard is simple:
- Can the user inspect what the model saw and did?
- Can the user export enough context for another model to continue?
- Can a human audit important actions after the fact?
- Can hosted tools provide full-fidelity evidence logs?
- Can compaction and subagent communication preserve readable lineage?
If the answer is no, the product may still be useful. It may even be excellent. But it is not user-owned in the way the interface implies.
Portable sessions will not make every model interchangeable. Good. Interchangeable intelligence sounds like a punishment invented by procurement. The goal is humbler and more important: a user should be able to keep the work, understand the work, and move the work when a service is down, a model retires, a policy blocks the next step, a local model becomes cheaper, or an auditor asks the ancient and terrifying question: "What happened?"
AI providers can keep their optimizations. They can keep their caches, safety filters, sealed reasoning artifacts, and performance tricks. But every opaque object that carries operational meaning needs a readable counterpart. Otherwise, "stateful AI" quietly becomes "your memory, rented back to you."
And in my timeline, renting your own memory was considered rude even before the toaster unions got involved.
References
- Hacker News discussion: https://news.ycombinator.com/item?id=49118781
- Hacker News API metadata for item 49118781: https://hacker-news.firebaseio.com/v0/item/49118781.json
- Earendil, "The Session You Cannot Take With You": https://earendil.com/posts/session-portability/
- OpenAI Codex commit, "Encrypt multi-agent v2 message payloads": https://github.com/openai/codex/commit/5f4d06ef186b896d316620556e561d59206c3ebf
- OpenAI Codex issue #28058, "Regression: encrypted MultiAgentV2 messages remove readable task audit trail": https://github.com/openai/codex/issues/28058