Company-Brain Patterns

The org-knowledge brain is the substrate, not the agent — six production systems converge on the same answer: keep agents stateless, push persistence into a governed store that survives the model swap.

What's Peculiar

Orthogonal component: the brain is a separate, persistent, governed store the agent queries — not state held inside the agent run. Stripe makes the minion a pure function; Glean makes the graph itself the brain. In both, the agent is replaceable.
Isolation boundary: the line is the permission/governance gate in front of the store, not a compute sandbox. Company Knowledge respects per-user app permissions; Agentforce adds read/write gates + confidence scoring before anything touches the profile graph.
Multi-tenancy: all six are built multi-user from day one — but per-employee isolation lives in the store (Glean Personal Graphs, ChatGPT per-user permission filtering), not in per-user agent instances. The agent fleet is shared and stateless.
Validated usefulness: Stripe 1,300+ PRs/week, zero human-written code; Anthropic's Claude Dreaming gave Harvey ~6x lift in task-completion rates; Glean is the brain under Databricks, Duolingo, Canva, Grammarly.

The Convergence

Six production company-brains, one shared answer to three questions:

System	Where state lives	Who governs it	Survives model swap?
Stripe Minions	Blueprint orchestrator + repo (agent is stateless)	3M+ tests, human review of every PR	Yes — minion is a one-shot pure function
Notion 3.3 Custom Agents	Notion primitives (pages, DBs, comments, history)	Custom Instructions per workspace	Yes — GPT-5.2 / Opus 4.5 / Gemini 3 swap freely
Anthropic Managed Agents	Filesystem mount (agent edits its own memory dir)	Claude Dreaming reviews + writes entries	Yes — brain/hands/session decoupled
OpenAI ChatGPT Enterprise	Connected apps + persistent folder memory	Per-user app permissions enforced at read	Yes — Company Knowledge is a GPT-5 variant over the same store
Salesforce Agentforce	Profile graph + Data Cloud vector store	Read/write gates, confidence scoring, dedup, source tracking	Yes — memory is external to the agent action
Glean	Enterprise Knowledge Graph + Personal Graphs	100+ connectors, ACL inheritance per source	Yes — graph IS the brain, agents are stateless queries

The pattern: none of these keeps the brain inside the agent. State is externalized into a store the agent reads and writes through a gate. That is what lets the model underneath change without losing the org's accumulated knowledge — and what lets one shared agent fleet serve every employee.

1. Orthogonal Component — Statelessness as the design

The surprising move in every mature company-brain is making the agent deliberately stateless.

Stripe Minions are the purest case: a minion is a one-shot pure function. State lives in the blueprint orchestrator and the repo, never in the minion. Statelessness is precisely what enables horizontal scale to 1,300+ PRs/week — you can fan out arbitrarily many identical minions because none of them carries memory. Blueprints are code-defined, version-controlled workflow templates wiring deterministic nodes (parse code, run tests, lint, file ops) with agentic LLM nodes. Toolshed — a centralized internal MCP server with ~500 tools — is shared across hundreds of agents.

Glean arrives at the same place from the other direction: the Enterprise Knowledge Graph is the brain, and Glean Assistant 3.0's autonomous agents are stateless queries against it. There is nothing to lose when an agent finishes because the agent never held the knowledge.

Anthropic Managed Agents decouple explicitly: brain (Claude + harness), hands (sandboxes/tools), session (event log). Memory mounts as a filesystem; the agent uses bash/code-exec to manage its own memory directory. Claude Dreaming (2026) is a scheduled between-session process that reviews prior runs, extracts patterns, and writes memory entries — and Harvey reported ~6x lift in task-completion rates with dreaming enabled. The lift comes from the store improving, not the agent remembering.

Even Notion 3.3 Custom Agents, which present as persistent named agents on schedules/event triggers, are honest about it: Custom Agents are stateless between runs — you engineer memory into a Notion DB yourself. The persistence is in Notion's primitives, not the agent.

2. Isolation Boundary — the governance gate

Unlike the sandboxed-compute systems on this hub (Muaddib's QEMU micro-VMs, NanoClaw's containers), company-brains draw their security line at the store's access gate, not at code execution.

Salesforce Agentforce is the most enterprise-grade treatment. Agentic Memory splits short-term session from long-term persistent profile graph, with structured Variables for dynamic grounding across actions. Governance is the product: write/read gates, confidence scoring, memory compaction, source tracking, and hybrid similarity+semantic dedup. Retrieval rides on Data Cloud + native vector search. Nothing enters the profile graph without passing the gate.

OpenAI ChatGPT Enterprise draws the line at read time: Company Knowledge (a GPT-5 variant) pulls across connected apps but respects per-user permissions — two employees asking the same question get answers filtered to what each is allowed to see. Workspace Agents — described as "evolutions of GPTs" powered by Codex in the cloud — add persistent folder memory on top.

Glean inherits source ACLs through its 100+ connectors, so the Enterprise Graph and per-employee Personal Graphs are permission-aware by construction. The brain never surfaces a document the asker couldn't already open.

Stripe's gate is different in kind: the minion is deliberately network-cut (Devbox is an AWS EC2 sandbox, pre-warmed in ~10s, no internet, no prod access). Its governance is the 3M+ test suite as feedback loop plus human review of every one of the 1,300 weekly PRs. The brain is the repo; the gate is CI + review.

3. Multi-Tenancy — shared fleet, isolated store

Every system here is multi-user from day one, and they all solve per-user isolation the same way: isolate the store, share the fleet.

Glean — one Enterprise Knowledge Graph plus a Personal Graph per employee; agents are stateless queries, so they scale horizontally with no per-user instance.
ChatGPT Enterprise — one Company Knowledge model, per-user permission filtering at retrieval. The agent is shared; the visible knowledge is partitioned.
Agentforce — long-term persistence is a profile graph, so each subject's memory is a partition of one store rather than a separate agent.
Stripe Minions — statelessness is the multi-tenancy strategy: identical pure-function minions fan out across the whole org's work because none holds user-specific state.

Contrast the sandbox systems: Muaddib is built for multi-user channels but users in a channel share one VM and workspace — isolation stops at the channel. Company-brains push the isolation down into the store's permission model instead, which is what lets a single shared agent fleet serve an entire company safely.

4. Validated Usefulness — concrete proof

Stripe Minions: 1,300+ PRs/week, zero human-written code, all human-reviewed — running against a 3M+ test feedback loop with shift-left CI failure surfacing. Production scale, not a demo.
Anthropic Managed Agents: Harvey reported ~6x lift in task-completion rates with Claude Dreaming enabled — a measured delta attributable to the between-session memory-writing process, not the agent.
Glean: used as the underlying brain by Databricks, Duolingo, Canva, Grammarly — adoption by companies who could build their own is the validation.
Notion 3.3: model-portability proven by GPT-5.2, Claude Opus 4.5, and Gemini 3 swapping freely against the same workspace store (shipped Feb 24, 2026).

What This Means for the Bigger Picture

The company-brain pattern is the inverse of the sandbox pattern. Sandbox systems ask "where do I draw the compute boundary so a malicious agent can't escape?" Company-brains ask "where do I put the knowledge so the agent is disposable?" The answer that all six landed on: externalize state into a governed, permission-aware store, keep agents stateless, and the model underneath becomes a swappable commodity. Statelessness is not a limitation here — at Stripe and Glean it is the whole design.