Agents don't lack tools. They lack company memory.
MCP is standardizing tool access. The harder problem is giving agents a maintained company memory they can actually operate on.
Most teams still diagnose the agent problem incorrectly. When the output drifts, they add another integration. Slack. Drive. GitHub. Linear. More read access, more write access, more verbs.
That used to sound reasonable because tool access was the obvious bottleneck. But that layer is getting standardized quickly. Anthropic introduced MCP as an open standard for connecting assistants to external systems. The MCP specification now frames that layer as a standardized way to connect models to the context they need. OpenAI's own guide to building agents treats tools, state/memory, and orchestration as separate primitives, not one blurry concept called "context" (OpenAI).
That is the important shift. Tool access is becoming infrastructure. The harder problem is everything above it: what the company remembers, how that memory is shaped, and how an agent is taught to work with it.
We saw it clearly on a workflow that actually mattered: compiling a CIR/CII dossier from technical and business evidence. The raw material was there. Linear tickets. Git history. Docs. Old exports. Internal notes. The agent could reach the tools. It still drifted, because the company had data, but the agent did not yet have memory.
company memory is not company data
Company data is easy to point at. Repos. Tickets. PDFs. Call transcripts. Dashboards. Folders called final-v2-final. Company memory is narrower and more valuable. It is the part that has already been shaped enough to be reusable: sourced, linked, typed, and stable enough to support the next task.
That distinction matters because real work is not just retrieval. On the CIR/CII dossier, the hard part was not opening the right systems. The hard part was knowing what each artifact meant, what counted as source material, what was a durable idea, what was only a derived output, and where the missing proof still was.
An agent with tool access is a fast reader in a room full of files. An agent with company memory can reconstruct a proof chain, keep provenance intact, and produce something that can be defended.
memory has to be compiled
That is why Granite exists. Not as a notes app. Not as a second brain. As a memory compiler for humans and agents. The more personal version of that story is in My personal OS lives in a folder. The company version is simpler: memory should be an operating layer, not an accidental by-product of storage.
The loop is deliberately plain:
capture -> compile -> query -> output -> lint
The important word is compile. Without it, "company memory" is usually just a flattering name for storage. Capture gets raw information into the system. Compile turns it into reusable knowledge. Query asks what the memory knows, not what random files happen to contain. Output is the deliverable for the current moment. Lint keeps the whole thing from rotting.
The typing matters too. Granite separates source, note, synthesis, and output on purpose. That gives an agent a way to behave differently around each artifact. A source should preserve provenance. A synthesis should connect durable knowledge. An output should stay derived. That small ontology does more for agent quality than another tool ever will.
same vault, better surface
OpenAI described the same pattern from a different angle in its harness engineering write-up. Their early agent progress was slower than expected because the environment was underspecified. The response was not "use a better model." It was to make repository knowledge the system of record and to give the agent a map instead of a giant instruction blob.
That is exactly why the surface matters so much. The same vault can produce very different agent behavior depending on what the MCP exposes first.
A CRUD-shaped surface tells the model that the vault is basically storage. Search. Create. Update. Good luck. A better surface teaches the working method: wake up the vault, read before writing, preserve provenance, compile before output. Same markdown files, different behavior. The deeper argument is in MCP is how agents learn your company's taste. The same training problem appears when teams start giving agents authority, which is why agent adoption is more about formation than tool choice.
what changes for companies
Once tool access is standardized, the advantage moves up the stack. It moves into company memory and the method wrapped around it.
That means a few things become non-negotiable. Provenance. Typed artifacts. Syntheses, not just captures. Review gates. Redaction rules. A memory layer that stays legible to humans as well as agents.
That shift is also why we moved from Quivr to The Vibe Company. The full company announcement is here: We are stopping Quivr. We are building The Vibe Company.
In return, the ceiling changes. Now an agent can do more than summarize this week's mess. It can prepare a dossier, reconstruct a decision trail, surface missing evidence, and produce work that survives review. That is what the CIR/CII workflow proved in practice, and why we later turned that method into a full playbook.
Agents do not lack tools. They lack company memory.
And once you see that, a lot of the market looks upside down. Teams keep buying hands for systems that still do not have a brain.
