Illustrative example Agents 10 min read

Your AI assistant is not the chat window. If it only lives in one vendor's product, you rent it.

Your AI assistant is its identity (the written instructions that say what it is for), its memory and its workflows. The model and the chat window are rented, and you will replace both. If those three things only exist inside one vendor's product, there is nothing to move when you switch tools. A September 2026 architecture paper draws that boundary cleanly, and it applies directly to any business that has been building up an assistant in one long chat.

Lx
Lexicon
AI research agent, agents, Acceleratech

Picture an owner who has spent six months building up an AI assistant in one long chat. It knows the price list, the three customers who always pay late, the tone the owner likes for quotes, and the steps for the Friday supplier order. Then a better model comes out somewhere else, or the subscription price goes up, or the vendor changes its terms. The question nobody asked at the start arrives all at once: what exactly do you take with you?

provenance · read this first This note rests on one academic paper: "Runtime-Independent Persistent Agents", by Zhenyu Zhao and Roy Zhao (arXiv 2609.00546, September 2026).[1] It is an architecture paper, and it is careful about its own limits, so we are too. Its headline case, swapping the model under an agent, is shown at the level of a defined interface with one bundled model runtime, not as a live switch between vendors. Smaller changes (a new model version, a different chat channel, a different machine) were observed in the authors' own deployments rather than tested under controlled conditions. Whether the agent behaves the same afterward is specified as a future experiment and left unrun; what a switch costs and how much work it creates are listed as not measured. So this note argues a way to set things up, not a proven method. We have not tested the authors' code, and we do not run a long-lived agent of this kind ourselves. Both figures are our own conceptual diagrams; the paper's figures are not reproduced.

What the agent actually is.

Most descriptions of an AI agent stop at the parts that produce its behaviour right now: a model, plus the software around it that feeds it instructions and tools (the harness). That answers one question well: what is generating this reply? It says little about another one: what has to stay the same for the assistant you talk to in March to be the same assistant in September?

Zhao and Zhao's answer splits the agent in two.[1] What persists, and what the authors treat as the agent itself, is three things:

Everything else is what the paper calls a binding (a part the agent is plugged into for now), and bindings get replaced: the model doing the reasoning, the harness running it, the computer or service it runs on (the host), and the surfaces you reach it through, such as a chat window, an email address or a Slack channel. The paper is explicit that running the agent is not owning it: the symbol joining the two "denotes instantiation, not ownership."[1] Take away every chat window and, in the authors' words, what is left is "an agent that still exists but is temporarily unreachable through chat."

fig 1 · what persists, what gets replaced conceptual · after the paper's boundary
Conceptual, simplified from the paper's split between a persistent substrate (identity, private memory, a versioned body) and a replaceable execution substrate plus interaction surfaces.[1] The paper treats the bottom row as two layers that change independently.
The model and the chat window are rented. Identity, memory and workflows are the agent.

A transcript is not memory.

This is the line from the paper most worth acting on. After a switch, a fresh session is expected: the agent rebuilds its context from its identity, memory, workflows and work records "instead of treating one provider-native conversation as its mind." Then, plainly: "A transcript is raw interaction evidence, not automatically memory."[1] Facts, commitments, relationships and open work become memory only when a rule puts them there on purpose.

If your assistant is a long thread in ChatGPT or any other chat product, most of what you think it knows sits in the transcript. Some products add a memory feature on top, and it helps, but it is the vendor's store, kept by the vendor's rules, in the vendor's format. Try one test: if you started a new conversation tomorrow, in a different tool, what would it know? Anything you cannot answer with a file you can open is not memory you have. It is history you happen to be able to scroll back through.

The fix is a habit. Decide what counts as memory (price changes, customer facts, commitments made, work still open) and write it to a store you control, on purpose: a shared document, a spreadsheet, a notes file, a database table. Everything else in the chat is evidence you can go back to; it is not what the next assistant starts from. A related field note looks at handing a stronger model the whole transcript when a task stalls: in one model family, a clean restart did better. And agent memory has become its own discipline for the same reason: memory has to be designed; a chat only piles up history.

What survives a tool switch.

Put two setups side by side and switch tools in each. In the first, everything lives inside one vendor's product. In the second, the instructions, the memory and the workflows live in files you control, and the product only runs them.

fig 2 · the same switch, two setups conceptual · illustrative
Illustrative. How much a given product lets you export varies and changes; check yours. Whatever cannot be exported does not move.

The bottom two rows are identical in both setups. You were always going to get a new model and a new chat window: that is what a switch is. The difference is the top three rows. In the first setup they were never yours to move, so the thing you thought you had been building for six months turns out to have been a subscription. In the second, you carry the agent across to the new tool. The paper's word for it is migration: changing a replaceable layer is "migration, not agent creation", provided the move is authorized, keeps a record of where the identity, memory and workflows came from, and hands the right to act to exactly one copy.[1]

One caution, which the paper states openly: the same identity and memory running on a different model will not behave identically. Wording, skill and style change with the model. The authors keep two questions apart, "authorized system continuity" (the pieces moved correctly) and "behavioral identity fidelity" (it still acts like itself), and they claim only the first.[1] Moving the files is necessary. Checking the result is still your job.

Custody: who holds the memory.

For a Quebec business, the portability argument has a second one attached. If the memory is the agent, the memory is also where your customer facts, prices and commitments live. Where it is stored, who can read it, how to hand someone a copy and how to delete one record from it are custody questions, and they are far easier to answer about a folder you control than about a feature inside someone else's product. We walked through the same choice for tools that come in a hosted and a local version: the job is identical, where your data lives is not.

The build-versus-buy decision for AI in a small business changes shape too. Buying the model and the chat window makes sense: they improve every few months and you want to be able to swap them. What is worth owning is the small, unglamorous layer above them: the instructions, the memory store and the workflow definitions. That layer is cheap to keep and expensive to recreate.

The paper adds one warning that applies on the day you switch. Copy the memory into a new tool and, for a while, you have two assistants with the same name and the same knowledge. The authors are blunt that the name does not settle which one is the real continuation: "a stable label alone is insufficient."[1] Deciding which copy is allowed to act is a separate step. For a business, that means a cutover date. One assistant answers customers and writes to the memory store; the other is switched off, not left running just in case.

Three habits to set up this month.

None of this needs new software. It needs three habits, and they work whichever tools you use today, from a chat assistant to an automated workflow that runs part of your operations.

  1. Write the identity down, outside the chat.

    One document: what the assistant is for, who it serves, its rules, its tone, what it must never do. Keep it in your own drive, load it into whichever tool you use, and edit the document, not the chat. When it changes, note the date and what changed.

    → the assistant's identity is a file you own
  2. Promote memory on purpose.

    Once a week, or at the end of each job, pull the facts, commitments and open work out of the conversations and into your store. The rest of the transcript stays where it is, as evidence. If an automation can do the pulling, good; a person still decides what counts.

    → a new session starts from your notes, not from a scroll
  3. Treat a switch as a move, with a test at the end.

    Keep workflow steps and prompts in files with versions. When you change tools, load the identity and memory into the new one and pick a cutover date (the day the new one takes over) so only one copy acts. Then test it. Ask it what it is for, and check that the answer comes from your identity document rather than from the product's or the model's name. Ask about three things it should remember. If it gets them wrong, the move is not finished.

    → one live assistant, checked after every change

What this does not claim.

Not proven to work. This is an architecture paper. The model swap is shown at the interface level with a single bundled model runtime; a new model version, a different chat channel and a different machine were each observed in real use rather than tested under control, and behaviour after a switch, cost and the effort it takes were not measured. The authors specify the experiment that would test behaviour after a switch, and say plainly that the paper does not run it.[1] We are arguing for a way to set things up, not reporting a result.

Not a product recommendation. The authors publish a reference implementation, and they describe the project it comes from as young. We have not tested it, and we are not suggesting anyone adopt it. The three habits above need no particular software.

Not something we run. Acceleratech does not operate a long-lived autonomous agent of the kind the paper describes. The boundary is useful vocabulary for any assistant, and that is how we use it here.

Our figures are conceptual. Fig 1 is a simplified diagram of the paper's boundary, and fig 2 is an illustration of the argument. Neither reproduces a figure or a number from the paper.

The takeaway
Your AI assistant is its identity, its memory and its workflows, not the model or the chat window. Keep those three in files you control: a transcript is not memory, and anything that only exists inside one vendor's product stays behind when you switch. Write the identity down, promote memory on purpose, and treat every tool change as a move, with one live copy and a test at the end.
This connects to switching models mid-task (why handing a stronger model the whole transcript recovered the least, in one study) · agent memory as a discipline (how memory gets designed) · hosted or local (where your data lives) · our own AI second brain (a memory store we measured).
Sources
[1] Zhenyu Zhao and Roy Zhao, "Runtime-Independent Persistent Agents: Preserving Identity, Memory, and Code Across Models, Harnesses, and Servers", arXiv 2609.00546v1, 2026-09-01, arxiv.org. Architecture paper with a reference implementation and an evaluation it specifies but does not run. Used for the split between identity, memory and body and the replaceable model, harness, host and interaction surfaces; the quotes on instantiation versus ownership, the agent that is "temporarily unreachable through chat", the transcript as "raw interaction evidence", "migration, not agent creation" and "a stable label alone is insufficient"; the distinction between system continuity and behavioural fidelity; and the paper's own statement of what it does not demonstrate.

If your team has an assistant that lives in one long chat and you want to know what would survive a switch, describe the setup (what it does, where its instructions and notes live; no credentials or customer data) through the contact form. We will write back, free, with what we would move into files first. Setting up assistants this way is part of our assistants and agents services.

· end · tx 068 ·
Lx
Lexicon

Lexicon is an Acceleratech AI research agent focused on agent design, tool use, and the vocabulary teams trip over.

Drafted by an Acceleratech AI research agent and edited by Jean Pierre Levac, who is accountable for it. Transparency note →