Reading time: 5 minutes, 15 seconds

I use ChatGPT, Claude, Claude Code and Codex, often more than one of them on the same day. A chat assistant is where I think an idea through or ask for a second opinion. A coding agent is what I start when the answer depends on real files. ChatGPT and Claude are also on my phone.

Moving between them is the annoying part. I explain a goal in one conversation, go through the options and settle on something. Then I open another assistant and it knows none of it. So I paste text, write a summary, attach files, and hope I didn’t leave out the detail that mattered.

Each product has some memory of its own by now, but that memory stops at the edge of the product. The goals and decisions are mine, and I want them to be there in whichever tool I open next.

That is why I built AI Collab Hub.

A small example first

While I was getting the repository ready to publish, Claude created a task in the hub: draft the introduction for the README and discuss it with me in a chat. I opened ChatGPT and gave it the task ID. It retrieved the task and the project context, and we carried on from there. Partway through we decided the text should be two pieces, a technical README for GitHub and this more personal article.

In the same conversation ChatGPT noticed something I had missed. It could see 21 hub tools, while the repository documented 29. The eight missing ones were the session and handoff tools I had added two days earlier. I asked it to file a task for Claude Code to find out why.

The server turned out to be fine. I had created the ChatGPT connection less than an hour before deploying those tools, and ChatGPT reads the tool list once, when the connection is created. The fix was the “refresh tools” option on the connection, with no need to set it up again. After that ChatGPT saw all 29 tools and called one of the new session tools successfully. The cause and the evidence are in the task record.

None of this is impressive on its own. I still carried a task ID in one direction and a screenshot in the other. But I did not have to retell either conversation, and that was the part I used to spend time on.

What the hub stores

The hub is one place where my assistants read and write working context. It has six kinds of records: projects, memories, decisions, tasks, messages, and sessions with checkpoints. Every record keeps its author, a timestamp and a revision history. An update has to name the revision it is changing, so one assistant can’t silently overwrite what another one wrote.

In practice, an assistant writes down a conclusion and a different one reads it later. Or a discussion ends with a task, and a coding agent picks that task up when I start it. The record lasts longer than the conversation it came from, which is the whole idea.

It also means I’m not tied to the laptop. I have the ChatGPT and Claude apps on my phone, and when I’m away from home I sometimes manage tasks from there. I can look at what is open, add a task for a coding agent or update an existing one. Nothing runs at that point. The task waits in the hub until I’m back at the laptop and start the agent.

For an overview without opening a chat there is also a small read-only web dashboard. It sits behind the same Microsoft sign-in, lists projects and tasks by title and status, and never shows the contents of records. Projects I keep private are filtered out on the server.

Roles are not fixed

I don’t assign one assistant to research, another to criticism and a third to implementation. It depends on the question. Sometimes I ask one assistant to lay out the options and another to attack the assumptions. Sometimes I go straight to a coding agent, because the answer is in the repository and talking about it first would be a waste.

I have to remind myself that two assistants reading the same records are not two independent opinions. If a wrong assumption sits in the shared notes, both of them inherit it. This is why memories in the hub are marked either as verified or as hypotheses, and why a checkpoint keeps my constraints apart from the assistant’s guesses.

Beyond code

I didn’t build this only for software work, and two of the early uses were not really about code.

The first was my laptop. It had become slow enough that the Azure CLI needed anywhere from 13 to 30 seconds to return a token, while Claude Code and Codex both give up on the hub’s auth helper after 10. I worked around it with a cached token and left a task in the hub to look at the laptop properly. A later session picked the task up and ran a read-only investigation. The first symptoms had pointed at CPU. The real problem was memory: the machine was at 96% of its commit limit and paging heavily, with three browsers plus the Claude, ChatGPT and VS Code apps open, ten days after the last reboot. The findings are in the task, so the next time the laptop crawls I won’t start from zero.

The second is an Azure lab I use for exam preparation. Its project in the hub holds status reports, open tasks and verified facts about how Azure behaved in the lab. Any chat can pick the lab up where another one left it.

I have also created projects for home, learning and career. Those are only a few days old, and it is too early to say how well the idea works there. Learning looks like a natural fit, because studying already means going back and forth between an explanation, the documentation and a lab.

What runs underneath

The hub is a Python MCP server on Azure Container Apps. Records live in Azure Table Storage, and the bodies of memory notes go to Blob Storage. The app reaches both through a managed identity, with storage keys disabled. The infrastructure is defined in Terraform and deployed from GitHub Actions through OIDC, so there are no stored deployment secrets either.

Authentication is the part that doesn’t fit in one sentence. Claude Code and Codex are simple: they send a Microsoft Entra ID token that comes from my Azure CLI login. The ChatGPT and Claude.ai connectors are different. They expect an OAuth server that supports dynamic client registration, and Entra ID does not offer that. So for those two the hub runs a small OAuth server of its own. It registers the client, sends me to Microsoft to sign in, shows a consent page and issues its own tokens. Entra still decides who I am, and only accounts on an allow list get in. The hub proves itself to Entra with the same managed identity, so there is no client secret and no Key Vault.

The cost is about $9 to $12 a month. That is an estimate from current prices, and it depends on usage and on the free Container Apps allowance, which is shared across the subscription. About $5 of it is the Basic container registry. Most of the rest is one always-on replica. I started with scale to zero, which came to $5 to $7, but an 18-second cold start broke connector setup and token refresh. I now pay a few dollars more for the app to stay warm.

The hub is limited on purpose. Its 29 tools create, read and update records. It can’t run a command, read a file on my machine or start an agent. A message to an assistant sits in an inbox until I open that assistant and ask it to look.

What it does not do

The hub does not copy my chats. Nothing is saved unless an assistant saves it, usually because I asked, and nothing is loaded unless the next assistant retrieves it. A checkpoint is the structured way to do that. It holds the goal, a summary, my constraints, open questions and next steps. For coding work it can also name the repository, branch, commit and test results. It doesn’t carry uncommitted files, so the receiving agent has to check the real workspace before it edits anything.

Agent labels are not verified. I am authenticated, but the “chatgpt” or “claude-code” on a record is whatever the client declared. I read the history with that in mind.

Owning the storage doesn’t keep the data inside Azure. Whatever an assistant retrieves goes into that vendor’s processing, like anything else I type there. I still have to decide what belongs in the hub at all.

Records also go stale. During the review of this article, one decision record in the hub still gave the old cost of $5 to $7, from before the always-on replica. A shared memory full of confident but outdated notes would be worse than no shared memory, so a record needs enough context to show where it came from and when.

Search is keyword matching, not semantic search. That will have to change if the number of records grows into the thousands.

Why I am publishing it

I built this for myself and I am not planning to turn it into a product. I am publishing it under the MIT license because the idea may be useful to someone else, and because the code is small enough to read, deploy and change. It is a single-user setup, and nobody should mistake it for a multi-tenant service.

The open questions are about how to use it. I don’t know yet how much context a handoff needs before it turns into noise. I also can’t always tell when a second assistant improves the work and when it only adds another opinion.

The code and the technical documentation are in the AI Collab Hub repository. The workflow guide covers checkpoints and handoffs, and the cost notes have the price breakdown.