A little while ago I wrote about how I accidentally expanded my own brain.
That sounds dramatic, but the basic idea was simple: I started using AI systems to follow my messy curiosity around and turn it into something structured. Notes, transcripts, half-formed ideas, tool experiments, project context, weird rabbit holes. Instead of trying to become a perfectly organized person, I started building a system around the fact that I am not one.
That worked better than I expected.
But personal knowledge systems are the easy version.
The harder version is the company brain.
Because a company brain cannot depend on one person being organized. It cannot depend on everyone remembering to tag the right Notion page, update the right project doc, summarize the meeting, link the decision, and keep the source of truth clean forever.
That is not how work actually happens.
Work happens in Slack threads, meetings, rushed handoffs, client calls, GitHub commits, old project docs, half-updated Notion pages, and someone saying, “Wait, didn’t we already decide this?” three weeks later.
So the question I keep coming back to is:
Can you build a company brain that works even when the humans are being normal humans?
The problem with most company knowledge systems
Most companies already have a knowledge base.
Sometimes it’s Notion. Sometimes it’s Confluence. Sometimes it’s Google Drive, Slack pins, project management comments, random docs, a heroic operations person, and the collective memory of three people who have been around long enough to remember why things are weird.
Usually, the problem is not that there is nowhere to put information.
The problem is that the system quietly assumes people will maintain it.
It assumes people will stop after a meeting and write down the decision.
It assumes someone will update the project page.
It assumes the client context will move from the call transcript into the CRM.
It assumes the thing someone explained beautifully in Slack will become a reusable piece of internal knowledge instead of disappearing into search.
It assumes people will remember where the source of truth lives.
And then real work happens.
People get busy. They context-switch. They make a decision on a call, then immediately jump into another call. A project changes shape. A client says something important. A developer solves a weird issue. A designer explains why a pattern exists. Someone writes a great Slack message that answers the question perfectly.
Then it just… stays there.
The company technically “knows” the thing, but the knowledge is trapped in the place where it first appeared.
That’s the gap.
A company brain should not be documentation homework
I’m starting to think the phrase “source of truth” has done some damage.
Not because the idea is wrong. Companies do need trusted places for important information.
But in practice, “source of truth” often turns into a place everyone knows they should update, but nobody really has time to maintain properly.
So the source of truth slowly becomes a source of maybe.
Maybe this page is current.
Maybe this project doc has the latest decision.
Maybe the Slack thread has more context.
Maybe someone updated the task.
Maybe Ryan remembers.
Maybe Courteney knows.
Maybe it was in a meeting transcript.
Maybe it was in that one doc with the weird title.
A useful company brain can’t just be a place where people put knowledge. That asks too much of people.
I think it has to work more like this:
People create signals. The system turns those signals into memory.
That’s a different model.
Instead of expecting everyone to become perfect documentarians, the system watches the places where work already happens and helps clean up the trail.
Meetings become decisions, action items, open questions, and project updates.
Slack threads become reusable context.
Project docs get refreshed when the actual project changes.
Old pages get flagged when they look stale.
The company brain becomes less like a filing cabinet and more like someone who was in the room, took notes, remembered the important parts, and knows where to find them later.
That’s the dream, anyway.
The knowledge already exists. It’s just scattered.
This is the part that feels obvious once you see it.
Most teams are not lacking information.
They are drowning in it.
The useful stuff is everywhere:
- meeting transcripts
- Slack threads
- Notion pages
- Google Docs
- GitHub issues
- code comments
- pull requests
- client emails
- project management tools
- CRM notes
- calendar events
- random voice notes
- someone’s brain
The issue is not capture. We capture too much already.
The issue is digestion.
A meeting transcript by itself is not company memory. It is raw material.
A Slack thread by itself is not a decision record. It is a conversation.
A Notion page by itself is not a source of truth if nobody knows whether it is still true.
The real value comes from turning all of that raw material into something usable:
- What did we decide?
- Who owns the next step?
- What changed?
- What is still unresolved?
- What context will future-us need?
- Where should this live?
- Who is allowed to see it?
- When should we revisit it?
That is exactly the kind of work agents are good at helping with.
Not replacing the thinking. Not making the decision. Not pretending the company can run itself.
Just doing the annoying connective tissue work that humans are bad at doing consistently.
The interface matters more than people think
One trap I want to avoid is building a beautiful system that nobody wants to use.
That happens all the time.
Someone builds a perfect knowledge structure. Clean databases. Nice templates. Thoughtful tags. Project dashboards. Linked resources. A whole little cathedral of organization.
Then the team keeps asking questions in Slack.
That is not because the team is bad.
It is because Slack is where they already are.
For a company brain to work, I don’t think the answer is “everyone go use this new knowledge system perfectly.”
The answer is probably closer to:
- Slack is where people ask questions.
- Notion is where structured, team-facing knowledge can live.
- Meeting transcripts capture what actually happened.
- GitHub and project tools show what actually shipped.
- A private Markdown or Obsidian layer can be the workshop where messy thinking gets refined.
- Agents sit between those layers and help move context around.
In other words, the team should not need to know where every piece of knowledge lives.
They should be able to ask:
What did we decide about this?
Where are we with that client?
Has anyone solved this WordPress issue before?
What came out of the last meeting?
What are the open risks on this project?
And the system should know where to look.
That is a very different experience from “go search the wiki.”
The agent is not the brain
This is an important distinction.
The agent is not the company brain.
The agent is the interface, the librarian, the intern, the connective tissue, the thing that can move between systems and help make sense of them.
The actual company brain is the combination of:
- the source systems
- the permissions
- the workflows
- the review process
- the team habits
- the memory layer
- the boring rules about what can and cannot happen automatically
That last part matters.
A company brain is not just a RAG demo.
It touches client information, internal decisions, private conversations, credentials, HR-ish context, project history, and sometimes politically sensitive stuff nobody wants casually summarized in the wrong channel.
So the boring parts are not optional.
You need scoped access.
You need human approval before writes.
You need to know what the agent can read.
You need to know what it can change.
You need to know what it remembers.
You need to know how to make it forget.
You need to know which sources are canonical and which are just raw signal.
You need auditability.
You need boundaries.
I know that sounds less exciting than “just connect everything and let the AI figure it out,” but that approach feels like a great way to create a very confident intern with access to every drawer in the office.
No thanks.
My current mental model
The model I keep coming back to has a few layers.
1. Raw signal
This is where work naturally happens.
Meetings. Slack. Notes. Transcripts. GitHub. Project tools. Client calls. Rough dumps. Voice memos. Whatever.
This layer is messy because work is messy.
That is fine.
2. Workshop layer
This is where raw material gets processed.
For me, this is often Markdown, Obsidian, local files, or whatever private workspace lets the agent and me think out loud without pretending everything is final.
This is where patterns get noticed.
This is where messy notes become a project summary.
This is where a weird idea becomes a useful internal doc.
This is where I can ask, “What is actually going on here?” and let the system help me find the shape of it.
3. Canonical layer
This is the team-facing layer.
For many teams, this might be Notion. Or Confluence. Or Linear. Or a CRM. Or some combination of tools.
This layer should be cleaner. More intentional. More permission-aware.
Not everything belongs here.
The point is not to dump every transcript and Slack thread into the canonical brain. The point is to promote the useful parts.
4. Interface layer
This is where people interact with the system.
Usually Slack. Maybe Discord. Maybe email. Maybe a dashboard.
But for most teams, chat is the obvious place because it is already where questions happen.
The interface layer is where the agent becomes useful.
Not because it is magic, but because it can go fetch context, summarize it, ask follow-up questions, and draft updates without forcing the human to remember which system holds the answer.
What agents should actually do
When people talk about AI agents, they often jump straight to the dramatic stuff.
Autonomous employees. Self-running companies. Infinite interns. Whatever.
I’m much more interested in the boring stuff.
The useful company brain agent does things like:
- extract decisions from meeting transcripts
- draft action items for human review
- update a project summary after a call
- find stale docs that contradict newer decisions
- answer questions using approved internal sources
- turn a Slack thread into a reusable note
- summarize what changed in a project this week
- remind someone that an open question never got resolved
- compare current work against past decisions
- help onboard a new person by explaining how a project got here
None of that requires pretending the agent is a genius.
It just requires the agent to be useful, scoped, and consistent.
Honestly, that is enough.
A lot of organizational pain comes from small bits of context getting lost over and over again.
You don’t need AGI to fix that.
You need a system that remembers the boring important stuff.
The human still has to decide what matters
There is a tempting version of this where the AI just organizes everything.
I don’t buy that.
At least not fully.
The human still needs to decide what matters. The human still needs to know when a conversation is sensitive. The human still needs to approve project updates, client-facing notes, and anything that might affect how other people understand reality.
But the agent can make that easier.
Instead of asking a human to produce a perfect project update from scratch, the agent can say:
Here are the decisions I found.
Here are the likely action items.
Here are the open questions.
Here are the parts I’m unsure about.
Here is the project page section I would update.
Do you want me to save this?
That is a much better division of labor.
Humans provide judgment.
Agents handle friction.
The trust problem is the real problem
The more I play with this stuff, the more I think the technology is not the hardest part.
The trust model is.
Can people tell what the system knows?
Can they tell where an answer came from?
Can they correct it?
Can they stop it from saving something?
Can they see what changed?
Can they understand the difference between raw transcript, agent summary, and approved company knowledge?
Can they trust that private context will not leak into a public answer?
Can they trust that the bot will not “helpfully” update a client-facing page without approval?
These are not edge cases. These are the whole game.
A company brain that nobody trusts is worse than no company brain at all, because now you have a second reality floating around the organization.
So the goal is not maximum automation.
The goal is earned automation.
Start read-only. Start narrow. Start with low-risk sources. Show your work. Keep humans in the approval loop. Let the system prove itself.
Then expand.
What I want this to become
The version I want is pretty simple.
I want someone on a team to be able to ask:
What’s the latest on this?
And get a useful answer.
Not a hallucinated answer. Not a generic summary. Not a confident shrug.
A useful answer.
Something like:
The latest approved project summary says X.
The last meeting transcript suggests Y changed, but that has not been promoted to the project page yet.
There are two open questions: A and B.
The next action appears to be C, owned by D.
Want me to draft an update for review?
That would be huge.
Not because it replaces anyone.
Because it reduces the amount of organizational forgetting.
It helps the team keep its own context.
It turns scattered signals into shared memory.
The goal is not a perfect wiki
I used to think the dream was a perfect knowledge base.
Now I think that’s the wrong target.
A perfect wiki is too brittle. It depends on too much maintenance. It gets stale the moment people stop tending it.
The better goal is a living memory system with clear layers:
Raw signal stays raw.
Useful context gets extracted.
Important knowledge gets reviewed.
Canonical docs get updated.
People can ask questions where they already work.
The system keeps track of what it knows, what it thinks it knows, and what still needs a human.
That feels much closer to how real companies operate.
What I’m building toward next
The next practical pieces I’m interested in are small:
- meeting transcript to decision/action extraction
- Slack question answering against curated docs
- weekly project memory updates
- stale Notion page detection
- WordPress/codebase convention extraction
- review queues before anything gets written back
- better memory rules so agents remember useful context without hoarding junk
None of those are flashy.
That is probably why I like them.
The flashy AI demos are fun for about five minutes. The boring workflows are where the value is.
A company does not need another chatbot sitting in a sidebar waiting for someone to paste in context.
It needs a system that can follow the work, remember the useful parts, and help people pick up the thread later.
I don’t think the future is everyone becoming a perfect documentarian.
I think the better path is accepting that most teams already generate plenty of useful signal. They talk, decide, debate, ship, revise, and forget. The knowledge is there. It is just scattered across the places work actually happens.
The job of the next company brain is not to make humans more organized.
It is to make the organization better at remembering.
