You Became the Wire

If you run more than two or three LLM chats at once, you already know this feeling. You're not in one conversation. You're in five, and you're the thing connecting them.

One chat is drafting. Another is holding the plan. A third is tracking what's done and what's left. Each one is doing real work, and none of them can see the others. So you do the seeing. You copy an answer out of one chat and paste it into the next. You switch tabs to remind a second chat what the first one decided. You carry the thread from window to window because the windows can't carry it themselves.

This is the part nobody warns you about. A chat has no memory of the chat beside it. Every conversation is sealed. So the moment your work outgrows a single thread, you become the integration layer — the wire that shuttles context between sessions that have no idea the others exist.

For a while it works. You hold the project in your head and you move the pieces. Then it stops working, and it stops working in a specific way.

A chat fills up. The context window expires. Whatever that conversation knew is gone, and you rebuild it from memory into a fresh thread. You're pasting the same background into the same kinds of chats over and over, because the source files live in one project and the chat that needs them lives in another, and nothing crosses that line but you. By the afternoon you've become a very expensive router, and the routing is the whole job. The thinking was supposed to be the job.

I did this for months. I assumed the fix was tooling — a connector between chats, an orchestration layer, some way to make the sessions talk to each other so I could stop being the cable. I went looking for the better machine.

The fix wasn't a machine. It was three decisions, and they cost almost nothing.

The first: I named one home for each fact. This document is the source of truth for the plan. This file holds the spec. This database holds the live status. Each chat reads from the home instead of from me. The instruction was one line — this lives here, don't recreate it — and a question that used to take five rounds to settle now took one. The chats stopped asking me to carry the answer. They went and read it.

That's when I understood what had actually been wrong. I wasn't moving information because the work was complex. I was moving it because the same fact lived in five chats at once, each copy drifting from the others. I'd been treating a storage problem like a delivery problem. The carrying was the symptom. The scatter was the disease.

The second decision: I wrote down which chat talks to which, and what's allowed to move between them. Not “these coordinate” — this chat sends that, the other returns this, only when this happens. Once every conversation had a short brief telling it what to read, what to hand back, and what to leave alone, the thing I carried shrank. I wasn't moving context anymore. I was moving a decision.

The third: I separated what never changes from what always changes. The standing rules — how things are done, what the boundaries are — went into one document every chat reads on open. The live status — what's done, what's waiting, what's next — went into a database. I'd been holding both in my head and losing both whenever a window closed. Now the rules survive a session ending. The status doesn't need that session to survive, because it never lived there.

None of this is automation, and that's the point most people miss. What it bought me wasn't a system that does the work. It was a clear enough view of the work to see which handoffs were worth automating and which weren't. Some carry judgment, and judgment doesn't travel down a wire — keep those by hand. Some are purely mechanical, and a person doing them by hand is just a slow machine — those are where automation earns its cost. Until the structure existed, every handoff looked identical. After it, the difference was obvious.

This is the job almost everyone gets wrong when they bring AI into real work. They reach for a bigger tool. The tool is rarely the constraint. The constraint is that nobody decided what lives where, or which chat is allowed to say what to whom. Solve that and most of the orchestration you were about to build stops being necessary.

That decision — what lives where, who talks to whom, what's a rule and what's a state — is the work I do. It's not a tool I sell you. It's the structure underneath whatever tools you already have, the thing that decides whether your AI investment compounds or just multiplies the number of windows you're keeping alive at once.

If you've felt the exhaustion of being the wire, that's the signal. Not that you need more capability. That you need the structure that makes capability worth something.

Who owns the structure your AI work runs on — and what happens when the chat holding it expires?

A bigger tool never answered that. Structure does. It only has to live somewhere the next session can find it.