The Company OS
The Company OS Method.
The Company OS Method
Everything I build ships as one product: the Company OS. This page is how it gets installed. Eleven steps, in order, from how the company actually operates to a system its people actually use. The other nine pages in this rail are the components in depth.
The eleven steps
Every install runs this sequence, in this order, because each step is the input the next one consumes. Skipping ahead is how a company ends up with a clever demo grounded in nothing.
1 · Understand the business
How the company actually operates: priorities, departments, workflows, pain points, employees, leadership, tools, outside dependencies, and how AI is used today. Everything after this step is only as good as this step.
2 · Identify the right AI use cases
Where AI actually saves time, improves output, increases revenue, reduces cost, raises what employees can do, or replaces an outside dependency the company no longer needs. Not where it would be most impressive.
3 · Architect the AI operating system
The company brain, employee workspaces, agents, skills, routing, tools, integrations, memory, approval logic, and governance. Decided before anything is built, because the pieces are not independent.
4 · Structure company knowledge
Documents, previous work, strategies, decisions, policies, research, collateral and brand information become usable organizational intelligence: hierarchy, authority, context, source-of-truth rules, conflict handling, and the history that explains the rest.
5 · Build governance
What the AI can access, what it can do, when a human approves, when an authoritative source is required, what happens when information conflicts, and when the answer is UNKNOWN rather than a guess.
6 · Build the LLM environment
Instructions, prompts, retrieval, grounding, agents, skills, memory, tool calling, MCP, the Brand OS, workflows, QA and evaluations. The layer most pitches start with, deliberately sixth here.
7 · Connect real company systems
Files, databases, APIs, sales systems, business systems, live data. A brain that cannot see the company’s real state answers from memory, and memory drifts.
8 · Build the employee experience
Hide the complexity. An employee says build me the report
and the system knows what has to happen: which files, which rules, which approvals. Nobody should need to know how the machine works to use it.
9 · Test and QA
Facts, numbers, sources, formatting, brand, claims, workflow behavior, approvals, guardrails. Including requests the system must refuse, because proving it declines is harder than proving it produces.
10 · Roll out and train
What the AI can do, how workflows change, where information lives, how to work through the LLM, and how to make it part of normal work rather than a novelty beside it.
11 · Build the learning loop
Approved work, decisions, templates and outputs become reusable organizational intelligence. The system becomes more valuable the longer the company uses it, which is the difference between a tool and an asset.
One product, four named parts
The steps install one system with four components. The Company Brain is the knowledge core everything cites. Brand OS is the brand layer everything obeys. The Operating Loop is the cadence every request runs. The Gates are the layer that keeps it honest. The product itself is on the Company OS page. This cluster is how it gets built.
Where the method came from
One conviction, applied eleven different ways: never depend on a person remembering, and never depend on a model grading itself. Structure remembers. Fresh eyes grade. Humans decide.
None of the steps is exotic. Every one exists because something went wrong once and the fix became structure rather than a note in a document. The rest of this page is that history: the map of the other nine pages, the evidence that the method is code rather than opinion, and what changed across four builds of it.
The map
Where each of the other nine goes, so you can pick rather than read straight through.
The Operating Loop
The seven steps every single request runs, including the quick ones. Especially the quick ones.
Graph Engineering
What happens when a job is too wide for one session: fan out, verify with fresh eyes, merge one answer.
The Component Map
The nine layers inside a company brain, and what each is waiting on.
Agents
The full roster: 45 agents across nine departments, each with one thing it will not do. 19 have actually run.
Skills
Reference-first generators. Why adapting a gold standard beats designing from scratch at volume.
Guardrails
The Gates: rules that execute rather than remind, and a demo of the system saying no.
Changelogs & Memory
The least glamorous file in the system and the one I would save first in a fire.
Approach
How an engagement runs, from the first diagnostic question to walking away.
The Intake
The sixty questions that decide what the system will be, each mapped to the file it produces.
The evidence
Every claim above is a claim about mechanism, so here is the mechanism. These six shipped with the systems described in this rail, and each one answers with an exit code rather than an opinion.
Build-time QA gates
Every site I ship runs its checks inside the deploy: structure, metadata, links, house style, brand tokens. Errors exit non-zero and nothing publishes. Four independent builds run this pattern today.
The confidentiality scrub
A denylist read against every output text file, raw, before anything ships. This site’s own build fails if one term survives, and the gate’s real code is published with its failure history.
The pre-delivery scanner
A 381-line scanner codifying a client’s entire output checklist: banned terms, name rules, phone formats, style. Exit code, not opinion. A checklist a person runs is a checklist a person skips on a Friday.
The excerpt verifier
Proves every code excerpt published on this site verbatim against the repository it came from, and fails on any undeclared gap. Quotation as a checked claim rather than an assertion.
Self-asserting builds
The hub generators do not just produce pages, they assert them: chrome byte-identical everywhere, every internal link resolving on disk, every tool wired to its brand seed.
Constitution twins
A generator that keeps the agent-neutral copy of a system’s rules byte-synced with the master, because two hand-maintained copies of the same rules will always drift.
Four generations, with the diffs visible
Four brains for four businesses, each built on the lessons of the one before it. The interesting part is not any single system. It is what changed between them.
The constitution nearly halved, deliberately
Generation one ran 146 lines, because everything was being figured out for the first time. Generation two ran 80: adaptation converges where invention drifts, and everything only ever true of the first company came out. Generation three went back up to 110 on purpose, because that client was new to AI and every extra line bought plain language. The fourth is confidential, and the accurate thing to say is what the pattern shows: length tracks the reader, not the system. Compression was a judgment each time, never a habit.
Prose rules became executable gates
In generation one the house style was item seven on a checklist, which is asking a model to grade itself. By generation three the same rule was a regular expression inside the deploy with a non-zero exit code. Automation scripts by build: none, then three, then seventy-six, then a leaner five, because the third build automated everything and the fourth kept only what earned its place.
What never changed
Four rules survived all four generations untouched: read the map instead of crawling the folders. UNKNOWN over a guess. Never edit an approved file in place. Archive, never delete. Four out of four means those were the load-bearing primitives, found in the first build and never improved upon.
Anyone can present one good system. Four generations with visible diffs, kept mistakes and dated reasons are evidence of a practice: the failures produced the guardrails, and the guardrails are now code.
The charts behind this, constitution lines and automation per generation, are on the brains index, above the four walkthroughs themselves.