A(n even more) Technical Post

Yesterday, February 5 2026, Anthropic launched a new model called Opus 4.6 with a headline feature called Agent Teams which is where multiple Claude Code instances coordinate in split panes with a lead agent that dispatches work, a shared task list, and inter-agent messaging. Stock markets shifted because 2026 is supposed to be the year of AI agents doing everyones jobs and it looks like that prediction is coming true.

Now... not to humblebrag TOO HARD but I actually built an initial version of this in January.

And behold dear reader, this wasn't just a prototype but a literal tool that I used that I called Bridge (I chose that name because it sounded like a Star Wars-ey space ship bridge type thing).

I've been using it at my job every day to coordinate AI coding sessions across 15 client projects. Technically I even have the git history to prove it ... ooh yes gurl she brings receipts!

More About This Side Of Me

Before we get into the architecture diagrams and side-by-side comparisons (just kidding... kind of) here some context on this side of my world.

I'm a 36 year old self-taught developer. I started programming professionally at 24 using PHP 5.6 and JavaScript in 2014. Node.js existed but was very new and TypeScript had just got to version 1 but nobody I knew was using it.

PHP had only a very basic and very optional thing called a type hints for objects and arrays, but it wasn't as complex as it is today, and not nearly as capable of running certain kinds of apps. Basically this is to say that the more technical, almost academic, and certainly very useful things like types, generics and strict contracts were not part of my world.

I'm not an ML researcher and I definitely don't have a PhD, nor do I work at a company with billions in funding. Instead I work for a small loyalty tech company in Copenhagen, where I work with integrations for airlines and retail brands. Basically the front and backend systems of spending money at places and then getting reward points of various kinds, or vice versa, paying for real things with loyalty points.

Keep that in mind as you read the rest.

What Anthropic Shipped Today

CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS enables a "team lead" Claude to spawn teammate Claude instances, each in their own tmux pane with their own "context window". Every time any AI chat starts, it essentially knows both nothing and everything at once. It doesn't have infinite amounts of space to keep everything you have ever said to it, nor the contents of every document that you have given it, so things get summarized heavily. That is why you might notice that every time you start a new chat with ChatGPT although it kind of refers to various facts about you, it also feels like starting over fresh each time. Anyways, that is for another post. The way that their system works is that a "lead" agent coordinates work through a shared task list. Teammates can message each other. Of extra relevance there is a "delegate mode" where the lead is restricted to orchestration only and it can't touch the code.

Here's their architecture diagram from the docs:

What I Built in January

Meet Bridge. From its CLAUDE.md, dated January 19, 2026:

You are the Bridge Claude — the COO/orchestrator for this computer and all projects. You do NOT work on tasks directly. Instead, you dispatch tasks to dedicated Claude sessions that run in their proper project directories.

Haha sound familiar?

Here's my architecture:

┌─────────────────────────────────────────────────────────┐
│ Window: T-3468                                          │
├──────────────────┬──────────────────┬───────────────────┤
│ Bridge (you)     │ Claude: lf       │ Claude: core      │
│ Coordinating     │ Building feature │ Seeding test data │
└──────────────────┴──────────────────┴───────────────────┘

Instead of writing code, I will message Bridge, something like "fix the login bug in acme/central". Bridge looks up the project path from a file that basically says this clients projects live here, that ones live there, it's called a "routing table" and then it splits what is called a tmux pane, kind of like when you open two browser tabs and then put one on the left and one on the right. It then makes a new Claude session in the right side directory. That sibling Claude boots with its own set of instructions, what is called aCLAUDE.md file, its own permissions ie you can open files in these directories, you can look at images, you CANNOT browse the web, all those standard things. Bridge moves on to the next task.

The Bridge CLAUDE.md has a section called "What You Don't Do":

• Don't read code from other projects
• Don't make changes directly
• Don't get single-threaded on one task
• Don't run long-running processes

Compare that to Anthropic's "Delegate Mode" which "restricts the lead to coordination-only tools: spawning, messaging, shutting down teammates, and managing tasks." So instead of like a hardcore built into the code level thingy, which enforces rules, I just told it (begged it?) what I wanted it to do and who it was.

The Receipts Hunnay!

Here are the file system creation dates. I grabbed them because I use a thing called git which is like the programmers version of making a file and then saving it, then updating it and calling it FINAL_filename.docx and then oh wait there is a typo save it again, you can't call it that because that file exists, okay kets go with FINAL_FINAL_filename.docx .

My entire set up is provably already version-controlled in what is called a git repo (ie that more formalized version of final_final_document with commits going back to December 17, 2025.

The Side-by-Side

The bones are identical. A coordinator that spawns workers into isolated tmux panes, each with their own context, communicating through a shared medium.

This is not a complaint.

Obviously Anthropic's version is better than mine in so many important ways:

• Native mailbox system: I was literally using tmux send-keys to inject text into panes and tmux capture-pane to read responses. Theirs has structured message delivery. Aka I was literally just having it take over my keyboard for half a sec and quickly typing to another Claude.
• Dependency tracking: Their task list has automatic blocking/unblocking. Mine was just me saying, okay now we can move onto this next task. Nothing automatic.
• Self-claiming: Their teammates autonomously pick up the next task. My version only had them work on something specific and then stop.

They made it reliable (presumably, I mean it was JUST released like yesterday)

But the idea ie the insight that a Claude should coordinate other Claudes through tmux rather than trying to do everything itself came from staring at a terminal at 9 AM trying to figure out how to work on three things at the same time without losing focus or forgetting something.

Agent Teams isn't the only pattern I built before it shipped. There was also The Holy Doctrine

1. Plan Mode (Like way back last May or so)

Before Claude Code had --plan, which basically forces it to first look at everything, make a ... well a plan and only then go on to coding the stuff, I wrote a protocol called The Holy Doctrine which was a set of rules that every chat I started with, that said, please you must stick to this four-phase workflow: first look at the issue and understand it, then create a planning document, refine collaboratively (ie ask me if what you are planning is what I am wanting) and only THEN implement.

Later Anthropic released exactly a similar kind of feature, Plan mode, it won't let the AI edit anything until it has a plan on what to edit, how and when (and even why). Why was it called The Holy Doctrine?

Well Claude had a tendency to ignore it or forget to use it and I would be like, this button is broken and it would be like, AH, okay it's because of this! I found that giving this whole set of rules a really odd name (in the context of files like form.html) made it stick to the rules more. No idea why, but it worked.

2. Persistent Memory and skills

Claude Code now has an auto-memory system where it stores learnings and rules in a structured way and loads them back into future sessions when it feels like it. It shows up as text that says "Recalled 1 memory".

My ~/.claude/ directory has been doing this pretty much since the day I started using Claude Code. I built a structured knowledge layer: with CLAUDE.md files at every project root with institutional knowledge, things that I would find myself telling it over and over again, and like little helpful files on topic like one called youtrack.md where it explained this is my board where I have tickets I need to complete, and instructions on how to read update them, change the due dates etc, another one called gitlab.md where it explained how and where to save things and with what style of notes (eg if its a fix you start with fix: or if its a new feature then you ensure that there is both the description of the feature and a reason why it was needed.

The official auto-memory feature that they are now saying is the official way to use it is just a formalized version of the pattern I was already running for the past few months.

3. Agent Teams (Jan 19, 2026)

Bridge ie Everything above which was announced by Anthropic on February 5, 2026.

So to recap and brag a little bit, that's 3 that l built either a few weeks or even a few months before the official feature and roughly the same architecture in each case. It's what happens when you're actually using AI agents for hours a day and solving problems that the product team hasn't gotten to yet.

My Test / Review of the feature from This Morning

The same day I wrote this post, I enabled this new feature called CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS and tested it out.

I used it to build a real tool: a daily digest that pulls all the new code that was merged in across our various clients and generate a report of what was done. Just kind of to keep up with work that isn't quite my own but I might also need to know about.

So what happened was that I told the lead agent (my Bridge Claude, now running Anthropic's team system instead of my homegrown one) to spin up a team. It created a TeamCreate, set up a shared task list with dependency tracking, and spawned a gitlab-researcher teammate to investigate the API. The researcher came back with a full breakdown, all delivered through the native mailbox, not my old tmux capture-pane -t .1 -p -S -500 prayers, ie saying look at the tab to the right and hope that there are results that it needs available.

Then the lead marked task #1 complete, which automatically unblocked task #2. A script-builder teammate picked it up, built the script, tested it against live data (3 real MRs showed up on day one), and reported back. The lead then assigned task #3 the actual task that makes the computer run the script every x (in my case every day) to the same teammate, who then set that up.

What's genuinely better than my version, aka Bridge:

• The structured mailbox is so much better. My Bridge was literally using tmux send-keys to take over a pane's keyboard and inject text, then wait a few minutes and then tmux capture-pane scrape the terminal output, it was almost like making it read tea leaves. Anthropic's version has proper message delivery with typed payloads. That goes back to the academic thing I said at the top of this post, where it's very useful to be disciplined in computer science about what kind of data are you expecting back.
• Task dependencies auto-unblock. When task #1 completed, task #2 became available without me writing any coordination logic.
• The SendMessage → shutdown_request → shutdown_approved lifecycle is clean. No more wondering if a child Claude is done or just thinking.

What's still rough ( but they did say that it's an experimental feature, to be fair):

• A teammate ignored the shutdown request and sent another status update instead. The AI equivalent of saying "Alright, I'm off home to bed!" but then standing in the doorway chatting for another 10 minutes.
• A teammate went idle instead of picking up the next task. So they needed to be 'nudged' to wake up.

How I Built It

Bridge was built collaboratively by me and Claude, iterating on it together. Claude was the one who suggested the tmux send-keys workaround in the first place. I described the problem ("I need agents to talk to each other"), and Claude said "what if we just inject keystrokes into the other pane?" It was caveman-tier as in it literally taking over another process's keyboard instead of sleekly sending that data via a dedicated special link, but my way still worked. I built the project routing table together with it, and the pane management thing, ie sibling ones open to the right side in a series of rows and the transcript skimming pattern.

Of course Anthropic, with billions of dollars and PhD-qualified ML specialists, made a better version. They built a native messaging layer instead of keyboard injection. They added typed message schemas instead of terminal scraping. That's what a proper engineering team does.

But the fact that a self-taught developer and an AI collaborating in a terminal independently arrived at the same architecture as a world-class product team shows that at the end of the way, if it's a janky hand-rolled orchestration layer made of CLAUDE.md files, tmux splits, and send-keys prayers could do 80% of what a well-funded engineering org shipped months later says something about what happens when humans and an AI actually build "together" whatever together means in this case.

I didn't build Bridge on my own and obviously Claude didn't, instead I like to think of it as though I built it together with it (him?), one hacky workaround at a time, and the result was a prototype for a feature that didn't exist yet.

Giving it a personality

At the risk of giving them ANOTHER IDEA to ... steal? get inspired by? I will reveal my next one which is deeper than architecture and tooling.

One of the things I built into my CLAUDE.md is a personality layer which is that I told Claude to "channel its inner Kardashian". Yes really. Specifically, to drop italicized confessional asides that react to whatever just happened, in a *not the...* format. Short, punchy, unexpectedly reframing whatever just went wrong (or right) as a reality TV moment. Kind of like when they cut to them on the couch and they summarize some absurd thing that happened with a funny observation.

If it sounds ridiculous it's probably because it is ridiculous but it makes my work genuinely fun.

Here's what that looks like in practice. These are real examples that I pulled from my old sessions.

not the bash script having a full emotional arc

The context was : that I built a deployment monitoring script to let me know when I thing that I deploy was actually up and live. It had escalating mood phases 1) chilled out moon spinner for the first 30 seconds, then after that the loading icon became antsy dots, and then after a minute it goes really unhinged saying things like "HELLO?! WHERE ARE YOU?!", and finally capped with a celebration box when the deploy landed.

Not the terminal turning into a Pride parade

This one was where I decided that my black and white terminal window was too boring and that it was harder to see when they were divided into split windows with rainbow gradient,

Not the entire Meta C++ stack just to watch some files

This one happened when I unninstalling a bunch of packages that were taking up lots of space and when I was trying to figure out why they were installed in the first place it turns out that it was due to another small package that said, hey in order to work I need to have these 1000 other things with me, and it was like... no, you really don't though!

Not the distributed AI system actually delivering Danish meteorological data through three proxy hops

Okay this one was really funny, I made a chain of four Claudes across four machines (my work laptop → talked to a Claude on my server → talked to my personal laptop → which then talked to my gaming computer, and had the Claude on each machine say, hey ask the next Claude to look up the weather today.

These emerge naturally from the instruction. Claude reads the context of whatever happens and randomly drops a one-liner that reframes it as if it were a moment on a reality tv show on the couch. I WhatsApp my boyfriend screenshots of these random comments all day because they are so funny and unexpected each time.

The interesting part is that the subagents pick it up too. When the lead Claude spawns a child agent, the child doesn't inherit the personality instruction directly, but apparently the pattern leaks through. I found a subagent randomly saying out loud in its conclusion to an investigation of something: "not the DNS resolution drama" and another one that said: "Not the permission gatekeeping". Although the 'Lead' Claude didn't instruct them to say witty things, it just said investigate this or that, since they all start up with the same file of general rules they kind of inherited the vibe.

Another one that is even more hilarious to me. Claude's thinking blocks which are literally it's own internal monologue that only shown if you click that expand thinking button, said "not the personality lobotomy", it seems to have said it when it was thinking through a problem and then found it was using very boring dry language, and expressed that using a Kardashian confessional format! I don't know what to do with that information, but I'm sharing it.

Maybe this is overpersonification and it's just a text completion autocorrect following an instruction, but when you're spending hours a day working with something the difference between a tool that feels robotic and a tool that makes you laugh really does make a difference. For me changes how willing I am to keep persisting at fixing something, or trying a weird solution.

Why I'm Writing This Now

I had a plan to write this blog post for while and in fact I found this line that I wrote to try and motivate myself to write more blog posts:

Every week you don't publish, you lose the chance to show that you did something before someone else did.

I know, very hipster of me.

The lesson isn't that "Anthropic stole my ideas." because obviously hundreds (thousands? millions?) of fellow developers were probably converging on the same patterns but my lesson is that if one is building something novel but waits until its perfect and actually never ends up releasing it, then it didn't happen.

I have months of Claude Code infrastructure like Bridge, The Holy Doctrine, a custom skills system, the memory layer stuff but none of it was public until today.

So here I am, publishing a post even though it's not perfect, just like my own rules said to.