English | EN 
For decades, software teams have worried about human collaboration. Merge conflicts, documentation drift, and the dreaded knowledge silos. The eternal question of who changed what and why.
Then AI agents arrived, and we somehow decided the best way to use them was in isolation. One chat window with one agent. One task and one developer. The digital equivalent of hiring five experts and locking each one in a separate room.
I recently decided to try something different. Instead of choosing a single AI ecosystem, I let several of them loose on the same project. Different models from different vendors with different assumptions and strengths. Different tools and different harnesses. Devin, Cursor, GitHub Copilot, Antigravity, and Claude Code are all forced to cooperate within a single repository. Pure chaos.
And somehow, against all odds, it worked. Actually, it worked far better than I expected.
The secret was not the agents themselves. The secret was giving them a shared memory.
The accidental tower of Babel
At first glance, mixing AI tools sounds like a terrible idea. And in the long run, it is.
Each system has its own personality, its own context window, its own way of approaching problems. One agent wants to refactor everything. Another wants to add abstractions. A third wants to write documentation before touching code. A fourth behaves like an over-caffeinated architecture consultant. (Editor’s note: a good simulation of me).
Without coordination, the result becomes chaos. The repository fills with duplicate investigations. Questions get answered repeatedly. Different agents independently rediscover the same conclusions and the context fragments across conversations.
Sound familiar? It is exactly the same problem humans have.
The moment multiple intelligent actors start collaborating, shared memory becomes more important than intelligence.
The surprising weakness of modern AI
People often talk about reasoning benchmarks, coding benchmarks, and context windows. What gets discussed far less is memory. Not model memory, but organizational memory.
An AI agent can analyze ten thousand files in a repository and then forget everything when the session ends. A new session starts tomorrow and repeats the process. And if not on your machine, on a teammate’s.
It feels impressive until you realize how much effort gets wasted. I kept seeing the same pattern. Claude would discover something useful. A week later, someone or something else would investigate the same area. Then a third agent would arrive at nearly the same conclusion from a completely different angle.
Each agent was individually smart. Collectively, they had the memory of a goldfish.
This goes for both findings and failures. Why are we repeating the same thing multiple times to get to the same outcome? Because we, the developers, and our trusted partners, the agents, do not keep track of what we’ve already tried and what worked, why it worked, and what failed.
AgentOps changed the game
This is where AgentOps became far more valuable than I originally expected. Instead of treating AI work as conversations, AgentOps treats it as knowledge, as every meaningful finding becomes an artifact.
Reports, investigations, audits, reviews, and architectural observations are lessons learned. The next agent entering the repository does not start from zero. It starts by reading what previous agents discovered.
That single change transformed the entire experiment. It forces the agents to stop acting like isolated contractors and start acting like members of a team. Not through direct communication but through shared memory.
Something strange started happening
After a few hours, I noticed a pattern. Different agents began contributing different types of value. Their personas (or core model) started to shine through.
Claude often produced deeper investigations and broader architectural reasoning. Gemini excelled at implementation work and rapid iteration. GPT integrated naturally into the daily coding flow.
Devin handled larger autonomous tasks particularly well. Antigravity brought its own perspective and occasionally challenged assumptions that the others accepted. VSCode just kept on being the workhorse it is.
The interesting part was not that they disagreed. The interesting part was that disagreement became useful. One agent would identify a problem. Another would challenge the conclusion. A third would validate it against the codebase. A fourth would propose an alternative.
The resulting knowledge became stronger than anything a single agent produced alone. This starts to resemble peer review more than prompting. Moreover, they were always polite and constructive, making the teamwork more or less frictionless.
The rise of synthetic teamwork
What surprised me most was how quickly this stopped feeling like interacting with tools. It started feeling like managing a distributed team. Not a team of humans. Not a team of agents. Something in between.
Each participant had strengths and weaknesses, and brought different assumptions. Each participant viewed the repository through a slightly different lens. The repository became a meeting place where ideas accumulated regardless of which system generated them.
For decades, software teams invested heavily in enabling collaboration between humans. We added version control, documentation, issue trackers, and a shared knowledge base.
We are now entering a phase in which those same systems must simultaneously support collaboration between humans and AI agents. That requires shared memory, a shared truth, and a ledger of what worked and what did not.
Without it, every agent becomes a temporary consultant. With it, agents become contributors to a larger body of organizational knowledge.
The model wars suddenly feel less important
The AI industry loves ranking models and every week brings a new leaderboard, a new benchmark, a new winner. My experiment left me wondering if we are focusing on the wrong thing.
The individual intelligence of an agent matters. But the collective intelligence of the system matters more. A mediocre agent with access to years of accumulated knowledge can outperform a brilliant agent forced to start from scratch. Human organizations learned this lesson centuries ago.
A company succeeds through shared knowledge, not individual genius. The same principle appears to apply to AI. The repository became smarter over time, even when the agents changed. That is a fascinating property. Knowledge accumulated independently of the models producing it.
The future looks less monoculture and more ecosystem
Many organizations are currently betting on a single AI provider. One model, one subscription, one ecosystem to rule them all. That feels natural today.
I am increasingly convinced it is temporary.
The future probably looks much messier. Different agents will specialize in different tasks. Different teams will prefer different tools, and different models will dominate different domains.
The winners will not be the organizations that pick the perfect model. They will be the organizations that allow knowledge to flow freely among them. AgentOps accidentally became proof of that idea. Not a framework for managing agents. A framework for managing shared understanding.
And the fact that something as simple as a set of instructions and folders can do that is just amazing.
Memory beats intelligence
The biggest lesson from this experiment was surprisingly simple. The value of a single AI agent grows linearly. The value of multiple agents sharing memory grows much faster.
Not because the agents become smarter, but because the organization becomes smarter. Every report strengthens future investigations. Every audit improves future reviews. Every lesson becomes available to every participant, human or synthetic.
The repository develops something that resembles institutional memory. And once that happens, the conversation changes. The question is no longer which AI agent writes the best code.
The question becomes how many minds can contribute to the same body of knowledge.
That is a much more interesting future. And for the first time, I suspect the real breakthrough in AI development may not be smarter models. It may be teaching them how to remember and work together.