A company brain takes everything your company knows, the stuff in docs, in people's heads and scattered across tools, and makes it usable as answers or context. For people and agents alike.
If the term is new to you, start with our full definition and origin story, then come back here.
The category is barely six months old, and dozens of companies now want to be called the company brain.
Some are open-source repos with a few hundred stars. Some are memory libraries for developers. Some are internal projects that were never meant to be sold. And a few are dedicated products.
They all answer the same brief, but they answer it in very different shapes.
Meanwhile, most teams don't have one. When we surveyed 149 teams in July 2026, only 17% said they have a company brain that works. Another 27% tried to build one and gave up, almost always on maintenance rather than technology.
So for our Company Brain 101 research we tested and analysed a dozen products that claim to offer a company brain, and interviewed more than ten people currently building them.
Key takeaways
- Every company brain solution, open source or commercial, breaks down into the same four components: getting signals, remembering, dreaming and pruning, and speaking and searching.
- The market splits into four families: self-hosted patterns, memory SDKs, bundled incumbents, and dedicated company brains. Each trades human upkeep against compute cost differently.
- The component that separates a working company brain from a stale wiki is maintenance. Only a handful of the tools we studied automate it, and all of them keep a human in the loop.
- Only 17% of the teams we surveyed have a company brain that works. Accuracy (77%) and permissions (63%) are the concerns that decide which family you should pick.
- If you have engineers with appetite and fewer than 50 people, self-host. If you're building your own agents, use a memory SDK. Everyone else needs a dedicated brain that automates upkeep without locking your context into one platform.
Every company brain has the same four components
We looked inside a dozen company brain solutions for our ebook, open source and commercial, personal and company-wide, self-built and bought. They differ almost everywhere.
Except in one place. Each one is built from the same four components. The brain gets signals, it remembers, it dreams and prunes, and it speaks when spoken to.
Getting signals
Getting signals is how the brain learns what happened in the company today. A steady feed is what lets it describe your company as it is now, whether a person is searching it or an agent is pulling context from it.
Tools and systems of record such as your CRM, project management, chat and developer tools produce activity at different speeds and volumes, so capture methods trade freshness against cost and noise.
Four approaches cover the field:
- Scheduled pulls. A connector syncs each tool at a fixed interval. Useful for slow-moving sources like docs and CRM records.
- Event capture. A webhook pushes each event to the brain the moment it happens. Useful for fast-moving sources like chat and tickets.
- Agent ingestion. An agent reads a source, keeps what matters, and writes a structured summary into the brain. Useful for noisy sources like meeting transcripts.
- Inference-time retrieval. Nothing gets stored. The brain queries live sources the moment a question arrives. Useful when the source system should stay the only copy.
Remembering
Remembering is the shape the brain stores knowledge in so it can be found again. The shape decides which questions the brain will be able to answer later.
Richer shapes answer more but cost more to build and maintain, which is why four coexist:
- Plain files. Markdown in a git repo, readable by any human and any agent. Useful for small technical teams that want zero infrastructure.
- Documents. A knowledge base with owners and permissions. Useful when humans are the primary readers.
- Vector index. Everything embedded and searched by meaning instead of keywords. Useful for large piles of unstructured content.
- Knowledge graph. Entities and relationships stored as typed edges, in the richest versions with a validity window on every fact. Useful when questions involve relationships or history.
Some brains combine two of these on purpose: readable docs for humans plus a dense structured tier that only agents open.
Dreaming and pruning
Dreaming and pruning is how the brain keeps its own company knowledge current without being told to.
- "Dreaming" is borrowed from GBrain's overnight dream cycle: a scheduled job in which the brain re-reads what it learned that day, reorganises it and re-links it, the way sleep consolidates memory.
- Pruning is the other half, retiring what no longer holds.
Company context goes stale in different ways:
- by age,
- by disuse,
- or by contradiction with what is actually happening in your tools.
Each way needs its own routine:
- Consolidation runs. A scheduled job reorganises and re-links everything that came in that day. Useful for keeping memory coherent as it grows.
- Time decay. Old and unused facts lose retrieval weight, or expire outright. Useful against silent ageing.
- Drift detection. The brain compares what docs claim against live activity in connected tools and flags mismatches. Useful for catching pages that reality has left behind.
- Review queues. Every change the brain proposes waits in an inbox for human approval. Useful wherever a wrong update costs more than a slow one.
Speaking and searching
Speaking and searching is where it all comes together: the place people actually search, and the place agents pull context from. Different askers need different doors. Humans want a conversation. Machines want an endpoint.
- Chat. Plain-language questions, answers with citations back to sources. Useful for everyday team questions.
- Hybrid search. Searching by meaning and by exact keyword at the same time, then re-ordering the results. Useful as the machinery underneath every other mode.
- Headless API or MCP. The brain exposed as an endpoint that other systems query directly. Useful for plugging the brain into coding agents, support bots and workflows.
- Dedicated apps. Purpose-built interfaces for a specific team or workflow. Useful when one use case deserves its own surface.
No solution runs all of these at once. Each one picks a single option per component, and those picks are what make two company brains behave completely differently.
| Getting signals | Remembering | Dreaming and pruning | Speaking and searching |
|---|---|---|---|
| Scheduled connector pulls | Plain markdown in a git repo | Nightly consolidation runs | Chat with citations |
| Webhook and event capture | Wiki or knowledge base docs | Time decay and fact expiry | Hybrid search |
| Agent-run ingestion that structures sources | Vector index over everything | Drift detection against live tools | Headless API / MCP into other tools |
| Retrieval at question time, store nothing | Ontological or temporal context graph | Human review queue for every change | Dedicated app interfaces |
The four families of company brain solutions
Every solution on the market makes a different trade across the five concerns our survey respondents named most: accuracy (77%), privacy and permissions (63%), maintenance burden (58%), the cost of daily ingestion and maintenance (58%) and setup effort (33%). The cleanest way to see the trade is cost against cost: what you pay in human upkeep versus what you pay in compute and subscriptions.
Plotted that way, the market splits into four families.
| Family | Who it serves | What it gives | What it costs you |
|---|---|---|---|
| Self-hosted patterns (GBrain, Sylph, self-built) | Technical teams that want full sovereignty | Open source, plain files, near-zero run cost, total portability | The maintenance lands entirely on your humans. This is the 27%'s story. |
| Memory SDKs (mem0, Letta, Zep) | Engineers building their own agents | Open-core building blocks, automatic extraction, temporal graphs | You assemble and tune everything above the memory layer yourself |
| Bundled incumbents (Notion AI, Rovo, Slack AI, Glean, ChatGPT and Claude Enterprise) | Organisations already living inside one suite | Lowest setup effort, permission-aware out of the box | Context lock-in: your brain belongs to the platform |
| Dedicated company brains (Slite Agent, Carrara, Pletor) | Teams that want the layer independent of models and platforms | Automated maintenance with human review, portability as a feature | A subscription, and you're trusting a vendor with the whole layer |
Most teams already have some version of the third family. Every major platform is building a brain on the slice of context it already holds:
- Salesforce with Slack AI,
- Atlassian with Rovo,
- Notion with Notion AI,
- Microsoft and Google inside their suites,
- OpenAI and Anthropic from the model side.
They are the fastest to switch on. The catch is what we call context lock-in.
A company brain has to read across every source, which means whoever runs it holds the most complete, portable version of your company that has ever existed in one place.
When that layer belongs to a platform you can't leave, you pay for the lock-in in every answer, every agent and every workflow built on top of it.
The squeeze is already visible: since mid-2025, third-party tools can no longer bulk-index Slack messages, and non-Marketplace apps are rate-limited and can't keep historical data.
The same trade shows up with many suite-native tools, which is why teams start hunting for alternatives once the lock-in becomes expensive.
10 company brain solutions, and what each one actually runs
For each tool: what it is, who it's for, and its four component picks, taken from public documentation and, where we could get them, interviews with the people building it. Entries are grouped by family without specific ranking.
Self-hosted patterns
1. Self-built: Claude Code + a git repo
The pattern half of our survey respondents who tried a company brain started with: a coding agent wired to a repository of Markdown, pull requests and plain-file search. No product, no vendor, and an engineer who keeps it healthy.
| Component | What it runs |
|---|---|
| Getting signals | Engineers add and update knowledge through pull requests. Subagents can research in parallel, then return compact summaries for the parent agent to save. |
| Remembering | The memory lives in the git repo: CLAUDE.md, rules, skills, runbooks and other Markdown files, all versioned with the rest of the system. |
| Dreaming and pruning | Session compaction is a command you run when context gets crowded. Longer-term pruning happens through human review, usually in pull requests. |
| Speaking and searching | Agents use read, glob and grep to find context in plain files, loading skills only when needed. There is no semantic index. |
Cost and fit. Free apart from model usage. Ideal for engineering-led teams under 50 people who want total control and don't mind that curation is a standing chore. For the workflows this unlocks, see why Claude Code needs a company brain.
2. GBrain
GBrain is the open-source personal brain Garry Tan published in April 2026, and the project that turned the YC Request for Startups into a category. Git keeps the durable record. A scheduled dream cycle maintains the graph and consolidates memory overnight.
| Component | What it runs |
|---|---|
| Getting signals | Email and calendar come in through scheduled collectors. General webhooks, voice notes, an inbox folder and custom skillpacks give you other ways to feed the brain. |
| Remembering | Your Markdown repo stays the system of record. GBrain indexes it with PGLite by default, or Postgres with pgvector for shared deployments, and turns local wikilinks into typed edges without an LLM. |
| Dreaming and pruning | Schedule the dream cycle overnight and GBrain maintains links, repairs citations and consolidates memory. Its "think" command also calls out stale context, uncited claims and contradictions. |
| Speaking and searching | Search blends vector and keyword retrieval with rank fusion. Three search modes trade cost for quality, and "think" turns the results into a cited answer. |
Cost and fit. Free to run beyond your own embedding and model costs. Built for one person's context first; it works as a company brain for a small technical team that is comfortable in a terminal. If you're looking at GBrain alternatives, the closest are Sylph below for a shared repo, and mem0 or Zep for a memory layer under your own agents. We reviewed it in depth in GBrain, reviewed.
3. Sylph
Sylph, from nao Labs, keeps the company brain in a git repo you can read and shape yourself. Agents can draft improvements, but people decide what lands.
| Component | What it runs |
|---|---|
| Getting signals | Sylph does not bundle outside data sources. You choose and configure the MCP connectors it can use, so prompts can pull live context from tools such as Slack or Gmail. |
| Remembering | The brain is the git tree itself: a central CONTEXT.md, domain folders for teams such as brand, sales, product, HR and legal, and Markdown files the agents can read. |
| Dreaming and pruning | Agents place proposed improvements in a drafts folder for human review. Once someone approves an output, Sylph compares the draft with what was kept and updates its own rules from the diff. |
| Speaking and searching | Teammates work through slash commands in Claude Code, Codex or Cursor. Because the memory is plain Markdown in git, people can inspect changes with familiar tools such as git diff and grep. |
Cost and fit. Free and open source. A founder-sized team that already runs its operations through coding agents will feel at home. The trade is that nothing is automated: the brain improves only as fast as a human reviews drafts.
Memory SDKs
4. mem0
mem0 is a developer memory layer that turns conversations into useful facts, then brings the right ones back when an app needs them. It is the most widely adopted option in this family, with a hosted platform on top of the open-source core.
| Component | What it runs |
|---|---|
| Getting signals | Developers choose when to send a conversation through an add() call. mem0 uses an LLM to pull out the facts worth keeping, so ingestion starts inside the app rather than on a schedule. |
| Remembering | Memories live in a vector store and can be scoped to a user, agent, session or organisation. Entity extraction ships in open source, while the interactive graph lives on the hosted platform. |
| Dreaming and pruning | v3 keeps every write instead of updating or deleting old memories. At search time, memory decay gently favours recent, frequently used memories without hiding the rest. |
| Speaking and searching | When the app asks for context, mem0 combines semantic search with keyword and entity signals. Developers can use its SDKs or connect through the hosted MCP server. |
Cost and fit. Open source is free. The hosted platform has a free tier and usage-based plans. Pick it if you are building your own agents and want memory that just works, and accept that you assemble everything above the memory layer yourself.
5. Zep / Graphiti
Zep keeps a temporal graph of people, events and facts, marking old information as expired when something newer makes it outdated. Graphiti is the open-source graph engine underneath it.
| Component | What it runs |
|---|---|
| Getting signals | Conversations, JSON and documents arrive as episodes through an add_episode() call or Zep's managed ingestion pipeline. |
| Remembering | Each episode feeds a three-layer knowledge graph: raw events, extracted entities and relationships, and broader communities. Facts are embedded and time-stamped, so the graph remembers both what happened and when it was true. |
| Dreaming and pruning | When new information contradicts an older fact, an LLM marks the old relationship as expired instead of deleting it. Entropy-gated fuzzy matching helps resolve likely duplicates without collapsing ambiguous names. |
| Speaking and searching | At query time, Zep combines semantic search, keyword matching and graph traversal. Because retrieval does not need an LLM, results come back in well under a second. |
Cost and fit. Graphiti is free. Zep's cloud is freemium with enterprise tiers. The right pick when your questions involve history ("what was true in March?") and you have engineers to tune retrieval.
6. Letta
Letta lets the agent decide what belongs in memory, while a sleep-time agent works on the shared context in the background. It grew out of the MemGPT research paper and is the most academically grounded option here.
| Component | What it runs |
|---|---|
| Getting signals | The agent can save and update memories through its own tool calls, while developers can write through the API. Native Slack, Telegram and GitHub integrations can bring in outside context. |
| Remembering | Memory is split into three layers: small labelled blocks kept in context, a searchable archive outside the context window, and the full message history. Letta stores them in Postgres. |
| Dreaming and pruning | A sleep-time agent rewrites shared memory in the background. When the context fills up, compaction summarises about 30% of the messages and keeps the rest. |
| Speaking and searching | The agent searches and updates memory through tool calls. People can inspect and edit it in the Agent Development Environment, while developers work through REST APIs and SDKs. |
Cost and fit. Open source is free; Letta Cloud is usage-priced. Best for teams shipping stateful agents who want the agent, not a pipeline, to own its memory.
Vertical and internal brains
7. Pletor
Pletor turns brand rules, creative references and performance data into a shared memory its creative agents can use. It is a brand brain for marketing teams rather than a whole-company brain, and it's in this list because it shows what the pattern looks like when it's scoped to one function.
| Component | What it runs |
|---|---|
| Getting signals | Brand nodes and data feeds bring in guidelines, references, performance data and competitor signals. The system works across text, images, video and audio. |
| Remembering | Pletor keeps those inputs in one living Brand Brain, connecting what the brand says, makes and learns from performance. Storage internals are undisclosed. |
| Dreaming and pruning | People stay responsible for taste and performance decisions, while feedback and results feed the next round of creative work. An inbox for brain amendments, inferred from your chats, is on the roadmap. |
| Speaking and searching | People work with the brain through chat and voice agents, or build creative workflows on Pletor's canvas. |
Cost and fit. Freemium with paid team plans. A fit for marketing teams that want their agents on-brand by default. Its founders were also the most candid people we interviewed about the limits of autonomy: "The promise of having an open Claude that learns from your Slack and just runs things is sexy. But it's quite hard to execute."
8. Gorgias Cortex
Gorgias built Cortex from the systems its teams already use, turning company knowledge into a graph its agents can navigate. It is an internal project, not a product, and the most complete self-built company brain we studied.
| Component | What it runs |
|---|---|
| Getting signals | Airbyte and a custom ingestion tool bring in Postgres, Notion, Gong, GitHub, Linear and HubSpot. Long transcripts are chunked and embedded so they stay searchable; low-volume tools are queried live over MCP. |
| Remembering | The result is a knowledge graph of roughly 12,000 typed Markdown nodes in GitHub, connected by relationships the agent can follow. |
| Dreaming and pruning | The team studies conversation traces to spot missing context. A scheduled maintenance loop groups recurring gaps into pull requests that improve the graph, and CI checks catch duplication and contradiction before merge. |
| Speaking and searching | The agent starts with task-specific skills, then follows relationships through the graph until it has enough context to answer. A typical query costs 10 to 30 cents. |
Cost and fit. Not for sale, and that is the lesson. Gorgias can afford both jobs a self-built brain demands, curating the content and re-architecting the system as the field moves, because it has an eight-person internal AI team. Most companies don't.
Dedicated company brains
9. Carrara
Carrara is a cloud brain replicated into a native Mac app, with every memory approved by a person before it enters the brain.
| Component | What it runs |
|---|---|
| Getting signals | Every hour, Carrara pulls from Granola, Gmail, Calendar and Slack, resolving each teammate across multiple email addresses. Composio makes it easier to add new sources. |
| Remembering | The shared memory lives in Neon Postgres, while a native macOS app replicates it locally for each teammate. |
| Dreaming and pruning | Nothing enters the brain without review. A dedicated acceptance interface keeps every memory human-approved. Automated pruning is still to come. |
| Speaking and searching | Agents connect through a custom MCP server, while teammates use the native macOS app. |
Cost and fit. Early-stage; pricing not public. The interesting bet is the review-first design: it accepts slower growth of the brain in exchange for never storing something a human hasn't seen.
10. Slite Agent
Slite keeps the docs people already use, then adds review, expiry, maintenance and cited answers around them. It is our own product, so read this entry as the design choices we made rather than a verdict.
| Component | What it runs |
|---|---|
| Getting signals | Slite Agent live-syncs across 20+ sources, Slack, Drive, Notion, GitHub, Jira and more, so it can bring the most current company context into every inference. Docs and attachments in the workspace are the core. |
| Remembering | People and agents push context into Slite's knowledge base with verification tags, owners and expiry windows that make its status clear. Docs stay the storage. |
| Dreaming and pruning | With auto-maintenance, Slite regularly fact-checks your docs against the rest of your company data. Suggested updates appear as side-by-side diffs in a triage view, where you decide what changes. Nothing publishes without approval. |
| Speaking and searching | Slite Agent answers with citations in the app and API, and downranks unverified sources. Its MCP server lets other agents search, create and maintain knowledge too. |
Cost and fit. Per-seat subscription. Built for teams of 50 to 500 that want a company brain that maintains itself and stays readable by humans, without the context ending up inside a platform they can't leave.
What the people building company brains agree on
The companies above disagree on almost everything: retrieval strategy, graph or no graph, how much to automate. Across the tools we studied we found five different rerankers, three search philosophies and no shared benchmark.
But on four things, everyone we interviewed landed in the same place.
- You'll maintain the company brain forever. At Slite we're regularly approached by companies that have already tried to build a company brain in-house, and the hardest part is always maintenance. A self-built brain is really two jobs: curating the content, and re-architecting the system as the field moves. Gorgias can afford both, but for most teams, the second job is the one nobody budgets for.
- AI is not ready to write to your company knowledge unsupervised. Auto-created knowledge works in personal brains, because you have no conflicts with yourself. Company context is different: agents fail at telling a scoped plan from a long, presumably authoritative Slack conversation about a potential change. Which is why every company offering a company brain solution is defaulting to human triage: Pletor is building an inbox for amendments, Gorgias routes every graph fix through a reviewed pull request, Sylph's agents can't promote their own drafts, Carrara approves every memory, and we built Agent Triage into Slite before shipping the Agent.
- Capture has to happen where the work happens. Even the most committed knowledge base users told us they couldn't keep feeding it. "You have to be very purposeful about feeding the machine, and even with the best of intentions from me trying to drive that thing, I wasn't doing it either," said Glen Sykes, Chief Product Officer at Spoor. So capture is moving into the work itself: Gorgias mines its own conversation traces, Pletor infers amendments from chats, and Slite Agent watches activity in connected tools rather than waiting for anyone to write things down.
- People will keep asking the brain questions. Agents will ask more. mem0, Guru and Slite all shipped MCP servers this year, and Gorgias exposes one for code-first teams. Once a company runs real agent workflows, agent queries outnumber human ones by orders of magnitude.
Which company brain do you need?
Three questions decide most of it: how big is your team, what worries you most, and who would own the brain internally.
| If | Choose | Why |
|---|---|---|
| Engineers who'd enjoy this, 50 people or fewer, and cost is the worry | Self-hosted (GBrain, Sylph, self-built) | You have the engineers and the appetite. Build it, own it, pay almost nothing. |
| Engineers, 50 or fewer, and wrong answers are the worry | Memory SDKs (mem0, Zep, Letta) plus your own retrieval tuning | If accuracy keeps you up at night, you'll want your hands on the retrieval stack. |
| Engineers, but more than 50 people | Dedicated company brains | Your team can build it, but at this size nobody has the bandwidth to also maintain it. |
| Setup effort is the worry | Dedicated company brains | Dedicated brains have gotten fast to deploy, and you'll still own your context in a year. |
| Keeping it alive is the worry | Dedicated company brains | Maintenance is the thing you're worried about. Pick the category that automates it. |
| Who sees what is the worry | Dedicated company brains | Permissions need to be built into the layer, not inherited from a platform you can't leave. |
| Nobody technical, it has to just work | Dedicated company brains | No one's going to wrangle YAML files. You need something that works the day you sign up. |
| Some technical folks, no bandwidth, cost is the worry | Self-hosted with a light footprint (GBrain, Sylph) | Lean setup, plain files, near-zero run cost, without it becoming someone's full-time job. |
Whatever you pick, treat context sovereignty as a requirement. The company brain has to be its own layer. It sits above the platforms and the models, and owes loyalty to neither.
When a knowledge base is the company brain
There's one question none of the articles about company brains answer: does the brain sit on top of your knowledge base, or can the knowledge base be the brain?
Every vendor asserts its own layer. Our answer, and the reason we built Slite Agent the way we did, is that for most teams the docs people already trust are the right storage, as long as three things are true.
Every doc carries a status a human set: verified, outdated, expiring.
Something checks those docs against reality and proposes fixes, without publishing them on its own. And agents can reach the same verified layer people do, over MCP, with the same permissions.
That gives you the automated maintenance of the dedicated family, the readability of plain docs, and none of the lock-in of the bundled incumbents.
If that sounds like the brain your team needs, book a demo or start with Slite Agent. And if you want the full interviews behind this article, they're in Company Brain 101.
FAQ
Is Glean a company brain?
Glean is enterprise search with an AI layer: it finds and summarises what already exists across your tools. It does not maintain or correct that knowledge, and it keeps your context inside its platform. That makes it a bundled incumbent rather than an independent company brain layer. See our Glean review.
Are there open-source company brains?
Yes. GBrain and Sylph store the brain as plain files in git. mem0, Graphiti (Zep) and Letta are open-source memory layers you can self-host. All of them leave maintenance to your team.
How does a company brain stay up to date?
Through the dreaming and pruning component: consolidation runs, time decay, drift detection against live tools, and human review queues. The tools in this list differ most here, and it's the component that decides whether the brain becomes the stale wiki it replaced.
How much does company brain software cost?
Self-hosted options are free beyond model and hosting costs, but the maintenance lands on your team; in our survey, 27% of teams abandoned a self-built brain for that reason. Memory SDKs are usage-priced. Dedicated company brains are per-seat subscriptions.
