I Built an AI Team Shared Brain

AI models are evolving rapidly, and the price points and usage limits keep changing with them. Teams need a shared project brain that can survive those changes. Built correctly, that shared information layer can also seriously accelerate the work.

In the past two weeks, OpenAI launched Astra, a powerful model that can consume an included allowance much faster than the lighter options. OpenAI offered launch resets, then temporarily paused new sign-ups and upgrades to its $200 Pro 20X plan on September 10. Existing subscribers could keep the plan, but teams that wanted to adjust upward suddenly couldn't.

Anthropic also ended the extra Claude Code allowance I had been working with since its May increase. I don't know what either company's limits, plans, or available compute will look like next month. That uncertainty can disrupt real project work.

I spent this past week building a system to protect against that. It's an evolution of the “Claude Obsidian Flywheel” and borrows from the shared Notion workspaces that are popular in tech. I call it AI Team OS, and it uses a Git + Markdown structure.

The system protects the project when a model or vendor changes, and it creates a compounding feedback loop for every project and AI system connected to it. I'll explain.

(This is about to get pretty technical, buckle up. Or ask your AI agent to explain it.)

At the simplest level, it's one shared folder of plain-text files tracked with Git, the change-tracking system programmers have used since 2005. Every model participates in the same read-and-write system, either directly or through a verified handoff. There is no orchestration platform or agent framework to buy. The stack is folders, Markdown, and Git.

For this job, it has worked better than the paid knowledge systems I've tried. Here's why.

1. Plain text is the ONE common format across every model I use. Markdown is text with a little formatting. Claude reads it, ChatGPT reads it, Grok reads it, and I can read it on my phone. Nobody had to build a custom integration.
2. Every decision gets ONE entry, and the team treats the record as append-only. If a ruling turns out to be wrong, the correction becomes a new entry that points to the old one. Three models and one human can all read the same file and see the same history in order, with dates.
3. Handoffs come with a fingerprint. When one model passes work to another, the file travels with its SHA-256 hash, which is a fingerprint of the exact file bytes. The receiver checks the fingerprint and records “received.” It then separately records “accepted” or “blocked.” Matching hashes prove that the models have the same file. They don't prove that the work is correct or approved, so the second decision still matters.
4. The rules live in the folder too. One file says who can write what. One file is the charter, and changes to it require my approval. One file holds the current state and says right at the top that it is a snapshot rather than the authority.
5. The coordination layer adds $0 beyond the tools I already use, and it outlives every conversation. AI chats run out of memory. I've had that happen twice this week, and each time I picked the work back up from the files instead of starting over. The folder remembers so the chats don't have to.

The scoreboard so far: 2 shared folders, models from 3 companies writing into them, 6 core files in each, and more than 40 recorded decisions in the first 5 days of the second one.

Now the honest part (hear me out). The system still has limits. One model can change a file but can't run Git on my machine, so another model handles the commit. That asymmetry has bitten us. Twice, a model reported saving a file that never actually reached the disk.

The rule now is simple: you don't get to say “saved” unless the machine holding the file reads it back. We now have a harness for that check.

The project work is protected because I can route any model into it. Each model starts with a progressive and compounding understanding of the work, the prior decisions, and the things that have already failed. It's very very cool.

I like a lot of the AI tools being built, but AI has gotten smart enough to work intuitively with basic, connected systems. The security rules still matter. Keep credentials and client material out of the repository, use private access controls, maintain backups, and assume anything committed may remain in Git history even if someone deletes it later.

If you can write a text file, you can run this. A system with this kind of continuity used to take a team of people and a budget, and there is never enough budget.

Start with one folder, 6 files, and a rule that every important decision enters the shared record. As the models keep changing, the project memory can stay in place and keep getting smarter. I'm excited to see what this lets us build next.

Stephen