I keep noticing the same sticker on laptops: have your agent talk to my agent. Somewhat of an 'insider' joke for folks to showcase their advanced AI usage. What does it actually mean though? How can we truly have an artificial intelligence work on our behalf with someone else's artificial intelligence? And how do we stay sane and aligned in teams where everyone suddenly has 'AI superpowers'?
I've spent the last four months building a system to address these questions for my team at Cisco. The tricky part is avoiding AI hallucination and making sure current context is used.
AI superpowers make individuals accelerate from zero to 60 in the blink of an eye
When I got my hands on Claude Code and Codex, like many people, I became mesmerized with the capabilities and the acceleration it can have on so many parts of office work. Have an idea? AI can draft out a sketch for you. Want to research the fundamentals of that idea? It can spin up multiple research agents, scrape the web and find what's already out there. Want to see what the idea looks like in action? It can start coding a proof of concept. With enough documentation and context, it can even connect to real data and other applications and build something that actually functions.
All of this can increase an individual's productivity manifold. I've written before about saving 150 hours on a single analysis, and about the dependency that comes with the magic. The individual benefits are well-covered, but benefits extend beyond (and so do the problems).
Individual speed creates a team problem
In team settings, AI can capture and summarize meeting notes, assign action items, and review work. Like most things, having multiple perspectives refines ideas, and that's true for AI-generated content too. Someone builds something; if someone else reviews it, they find gaps, improvements, or a better idea entirely. With AI, everyone can even simulate some of those reviews by giving their agents a specific role, so a work item doesn't just get built but gets read back through several different lenses.
I still think there is significant value in having other people (and their agents) add to those reviews. My agents learn continuously from my engagements, and I keep tuning how they communicate and what they should pay attention to. That tuning is exactly why my agents' review is not a substitute for my colleagues': mine are calibrated to me.
Here is where it gets difficult. In a world where everyone accelerates their individual output (even after discarding the AI slop), the hard part is keeping a fast-moving group on the same road. I'm currently involved, to some extent, in 23 different initiatives. Different owners, different tools, most with activity every week and several with decisions made every day. It's very easy to get lost in that. No one (including their agents) is doing anything intentionally wrong, but by the time someone starts working on something, the route might already have changed. So I built a system to give me, and everyone involved, some sanity back.
The shared second brain: three moving parts
The 'shared second brain' is a single Git repository that holds project capsules and individual member contributions. As I work with my AI on a given project, it captures progress, decisions made, and stakeholders added or changed, and contributes that into the central place. Someone else on the team who wasn't in the meeting where a decision was made, or who has no idea what I've been doing on my own, just reads the repository and works with full context.
Three elements make that work.
Individual contributions have to be near effortless. A shared second brain is only intelligent if people actually capture and contribute their part. Without that, it becomes just another stale file-and-folder system, and there are already enough of those. AI has some handy tricks here. Skills can guide repeatable tasks and make sure the relevant steps and considerations are taken every time, and (the part that matters most) they can be auto-invoked. That means the contribution kicks off from however someone happens to be talking to their AI, as long as the right keywords show up. Nobody has to remember a process.
Reconcilers do the housekeeping. Once someone's contribution is captured, their granular detail has to be sorted into the initiatives it actually belongs to. A combination of Python scripts and AI synthesis handles that, helped by the tags the skills already applied on the way in. Reconciliation needs computation, so it goes beyond what a plain Git repository offers. I started by running the scripts on my own laptop because that was the fastest thing that worked, and it's now moving onto a virtual machine as a scheduled job. Which removes me as the orchestrator, and that dependency was the weakest part of the design so far.
Project capsules carry the live signal. Each initiative has one file with a short overview and links to the places where the real work happens: a code repository, a Webex space, a dashboard. Underneath it sits a running, dated log of progress, decisions, and open asks. From there, anyone can run one command to hand their own agent the current state of an initiative and start working from the same page instead of a private one.
How I know it's working
With an infrastructure like this, it's crucial to have mechanisms and trackers in place to ensure the system is working. A shared brain that's outdated or aggregating incorrectly is arguably worse than having no shared brain at all.
Four moving parts keep the system in check.
1
2
3
4
1. A sensitivity check runs before anything is committed. Whole categories of content are simply not eligible for the shared layer: anything performance-related, anything from a one-on-one, anything about a person rather than the work. This one is not a nice-to-have. The fastest way to kill a shared brain is for one person to discover something in it that they never intended to share.
2. Machine output is never allowed to overwrite a human. The reconciler can add, and it can flag a conflict, but it cannot replace human-authored content with its own synthesis. That single rule is what makes the capsules readable six weeks later, because you can still tell what a person decided from what a script inferred.
3. The live signal is append-only, with provenance. Every entry is dated and carries where it came from. Nothing gets quietly rewritten into a cleaner version of the past, which means a wrong entry can be corrected in the open rather than disappearing.
4. The system displays its own gaps. The room above shows each person's last contribution in days, so a stale corner looks stale instead of looking finished. And where a number isn't measured, it shows a dash rather than an estimate. I'd rather publish the dash than a plausible figure, which is the same discipline I wrote about when AI nearly handed me a 5.6x overstatement.
The numbers I can source, from the repository's own history as of today: 23 initiative capsules, 688 commits over 125 days from 10 people, 137 individual weekly contributions.
Consumption is the number I actually wanted, and it took the longest to get, because writing into a shared brain is easy to count and reading out of it is not. A small hook now reports it from a local usage log: capsule loads over three reporting periods went 10 loads across 6 initiatives, then 17 across 9, then 25 across 10. Counts only, no initiative names, no timestamps, no queries leave the machine. And it is instrumented on my machine, so it's a validated number about one person and not a team rate. That's why the room still shows a dash for the team figure.
One more, because leaving it out would be the flattering version: 475 of the 688 commits are mine. Nine other people contributed the remaining 213, which is real adoption and not a rounding error, but two-thirds of a shared brain coming from one person is not yet a shared brain. It's a well-documented one. That ratio is the measure I'm using to gauge the system's success.
Still building
I'm still learning and evolving this system, so none of the above is meant as a blueprint for success. It's more in the spirit of starting a discussion, because the parts I'm least sure about are the ones I'd most like other people's answers to.
So I'm curious to chat if you've had similar challenges, or built something like this with a different implementation.