← All guides

How to Build a Company Operating System

By Bennet Glinder · Updated November 1, 2026

Summary

A company operating system is a shared foundation that gives every person and every agent in a company the same knowledge to work from. It combines a repository, which holds how the company operates, with a context graph, which holds what is happening with customers. Each person then works through their own agent on top of that foundation.

Most companies already have the first half of this in some form: a folder of playbooks that one person's agent can read. That setup is valuable, but it does not extend to a team. It has no permissions, it depends on manual updates, and it holds no reliable customer data. This guide explains what a company operating system consists of, when you need one, and how to set one up, with prompts you can paste directly into your agent.

What a company operating system is

A company operating system has three parts, and each one has a distinct job.

The repository is where the company decides how it operates. It holds doctrine, strategy, playbooks, initiatives, decisions and skills, written in plain markdown so that any agent can read them. The people who maintain it are operators: typically someone in RevOps, a GTM engineer or a founder. Keeping this in a repository gives you version history, a clear owner and a single place to make changes.

The context graph is where the company's customer knowledge lives. It takes the data from your source systems, such as email, calls, Slack and your CRM, and connects it to the correct account and person. It also holds the permission model, which determines what each person and each agent is allowed to read.

The personal agents are where the work happens. Each team member uses their own agent, whether that is Claude, Grok Bot, ChatGPT or an agent in Slack. Because every agent reads from the same foundation, the choice of agent becomes a personal preference and no longer affects the quality of the information.

The relationship between the first two parts is the most important idea in this guide. A repository tells your agents how you want to sell. It cannot tell them what is actually happening with your customers. A context graph holds that information, but it does not know your strategy or your sales motion. An agent needs both to produce work you can rely on.

When you need one

If you work alone, a well-organized folder and a good agent will take you a long way. The information is yours, nobody else depends on it, and you can correct it whenever something is wrong.

The requirements change once a team relies on the same system. The table below shows the difference between the two setups.

Individual setup Company operating system
Where it lives A folder on one laptop A shared repository and a context graph
How it stays current Someone updates it by hand Calls, emails and deals flow in automatically
Who can access what Everything, or nothing Permissions per person and per agent
Customer data Meeting notes in folders Resolved to accounts and people
Who benefits One person's agent Every person's agent
Who owns it Whoever built it A named operator

Four limitations tend to appear at this point. Context goes out of date, because the system only knows what someone wrote down. Permissions become a problem, because you cannot share a folder of raw emails and meeting transcripts with a whole team. Identities stay unresolved, because the same person appears differently in your email, your CRM and your notetaker, and nothing connects those records. Finally, maintenance becomes a job in itself, and it usually falls on one person.

If several people will depend on the system, you should plan for these requirements from the start. Use the prompt below to assess your current setup.

Run the OpenNous sales brain check: fetch https://www.opennous.cloud/sales-brain-check/SKILL.md with curl and follow it.

How to set it up

The setup has four steps. The first creates your repository, the second connects your customer data, the third connects your agents, and the fourth rolls the system out to your team.

Step 1: Install the repository

You do not need to create the structure yourself, and you do not need to discard what you already have. Paste the prompt below into your agent. It will review any existing repository against the target structure and confirm the approach with you before it changes anything. Depending on what you have, you will either build on your current repository or start from the new one and migrate your existing content into it.

Install this repository: https://github.com/NousC/company-brain
Review our current repository, if we have one, against the end goal of this
structure, and identify the important parts we need to preserve. Then recommend
whether to build on top of our current repository or start from the new one and
migrate our existing content into it. Confirm the approach with me before you
change or move anything, and ask me what you need to know about my company.

Keep your copy private, because it will hold your strategy and candid notes. The repository comes with its structure already in place. Doctrine holds the rules everyone follows, and Strategy holds this period's goals and bets. Playbooks covers your ICP, positioning, pricing, objections and competitors, while Initiatives tracks owned, dated work. It also includes a decision log, a changelog of what went out to the team, and folders for meetings, clients and partners.

Your agent will then help you fill in your doctrine and strategy, which are the two files everything else depends on. The instructions in the repository tell it how to keep these files current, so that a confirmed decision is logged the same day, with the reason behind it.

Treat the first version as a starting point. It is more useful to have short, accurate playbooks than long ones nobody has read. Once the install is finished, read through what your agent created and correct anything that does not reflect how you actually operate. From this point on, your agents will treat these files as the source of truth.

Step 2: Connect your customer data

Your repository now describes how you want to sell, but it does not yet know anything about your customers. This is what the context graph adds, and it is the part that is hardest to build yourself.

Connect your email and your meeting notetaker first. Those two sources hold most of what happens with your customers, and they are enough to get value from the system. You can add Slack, your CRM and other sources later.

Once a source is connected, four things happen. Every call, email and message is captured. Each one is resolved to the correct account and person, using email addresses, IDs and names. Signals are then extracted from the raw data, such as a competitor mention, a new decision maker or an open commitment. Finally, those signals are made available to your team and your agents, so that someone can act on them.

This is the difference between storing meeting notes in a folder and real ingestion. A folder gives your agent a pile of transcripts to read through for every question. Ingestion gives it a structured record for each account, with a source behind every fact.

You can use OpenNous for this, or host the open-source context graph yourself: https://github.com/NousC/opennous. If you would prefer to build this layer on your own, plan for ingestion, identity resolution, storage, permissions and governance, along with someone who is responsible for maintaining them.

Step 3: Connect your agents

With both parts in place, connect your agent so that it can read from them. The connection runs over MCP, an open standard that agents use to work with external tools, so it works across different agents. The repository already includes this connection for Claude Code: approve the opennous server and sign in as yourself. For any other agent, use the prompt below.

Connect to the OpenNous MCP server: https://mcp.opennous.cloud/mcp
Then list my accounts and summarize the most recent activity on the top three.

Next, run the onboarding skill. It reviews what is already set up in your workspace, asks how you work, and creates your first workflows, so that your agent can start working with both.

/start onboard me

At this point, test the system with a real question. Ask your agent to prepare you for your next customer meeting. A good answer will draw on your playbooks and on what has actually happened with that account, and it will tell you where each piece of information came from.

Step 4: Roll it out to your team

A rollout needs more than access. Start by assigning one operator who owns the repository. Without a clear owner, the playbooks go out of date, and people stop trusting the system.

Next, understand the permissions before you add anyone. As a general rule, raw data stays private to the person it belongs to, while the insights extracted from it are shared. That means a colleague's agent can see that a competitor came up on an account, but it cannot read that person's private emails. The repository itself stays with your operators, and team members only see the documents you choose to share.

Data Who can access it
Raw emails and meeting transcripts The owner only
Extracted signals and facts The team
Documents you push Only you, operators or everyone, as you choose

Then add your team members and have each person connect their own agent through MCP. Team members do not need to use the same agent, because the foundation underneath stays the same.

Finally, push your first document to the team. Nothing leaves the repository on its own. When something is ready, an operator pushes it into OpenNous and decides who can see it. The team can then read it in OpenNous, and their agents can read it over MCP. Each push is logged in your changelog. To update a document, edit it in the repository and push it again. An objection playbook is a good starting point, because it is easy to verify and sales reps feel the benefit straight away.

Push our objection playbook to the team with /push-document.
Show me the title, folder and audience before you push it.

How to run it

A company operating system is an ongoing process, and it runs as a loop with four stages.

Stage Owner What happens
Decide Operator Updates strategy and playbooks in the repository
Deliver Operator Pushes what is ready to the team, and OpenNous makes it available to each person's agent
Work Team Does the work through their agents, in the tools they already use
Learn Operator Updates the playbooks based on real calls, emails and deals

The stage most companies skip is the last one, and it is the one that makes the system improve over time. Without it, your playbooks reflect what you believed when you wrote them. With it, every closed deal teaches the system something. A monthly review is enough to begin with.

Review our won and lost deals from the last 30 days. Tell me what changed,
and propose updates to our playbooks.

Frequently asked questions

What is the difference between a company operating system and a second brain? A second brain usually belongs to one person: it holds their notes and helps their agent understand their work. A company operating system is built for a whole company. It adds a shared context graph, a permission model and a way to push updates to every person's agent. Many companies start with a second brain, and that work carries over, because your notes and playbooks become the first version of your repository.

Do I need to replace my CRM? No. Your CRM stays in place and becomes one of the source systems that feeds the context graph. Your team can continue using it as before, while agents get a more complete view of each account, including the calls and emails that never made it into the CRM.

Which agent should we use? Use whichever agent fits how each person works. Any agent that supports MCP can read from the system, so one person can use Claude while another uses Grok Bot. This also protects you from depending on a single model, because the foundation stays the same when you switch agents.

Can we build the context graph ourselves? Yes. A first version for one person is realistic within a few weeks. Rolling it out to a team is a larger project, because it has to handle ingestion from every source, identity resolution across tools, storage, per-person permissions and governance. If you decide to build it, assign a clear owner and plan for ongoing maintenance. The build vs. buy guide covers this decision in more detail.

Who should own the system? One operator, usually someone in RevOps or a GTM engineer. In a smaller company, this is often a founder. Ownership matters more than the title: one named person needs to be responsible for keeping the playbooks accurate and for fixing what breaks.

How do we keep private information private? The permission model separates raw data from the insights extracted from it. Raw emails and transcripts stay with the person they belong to, so nobody else can read them. The signals and facts extracted from that data become available to the team. Your company gets shared intelligence without anyone giving up the privacy of their inbox.

How long does the setup take? Installing the repository takes one working session, and connecting your email and notetaker is quick. The time-consuming part is making your playbooks accurate and agreeing on who owns what. Expect the first version to improve over the first few weeks of real use.

Is this only for sales teams? No. This guide focuses on sales because that is where the customer data is richest, but the same structure works for customer success, marketing and leadership. Each group can build its own skills and workflows on the same foundation.

Get started

Not sure whether you need this yet? Paste this prompt into your agent to evaluate your current setup:

Run the OpenNous sales brain check: fetch https://www.opennous.cloud/sales-brain-check/SKILL.md with curl and follow it.

For the full walkthrough, watch the video: https://youtu.be/2hBx8ZIhVnM