Why does Ai1 store different kinds of knowledge differently?
A client's billing balance must be exact and auditable. The nuance of a sales relationship is best captured in prose and retrieved by meaning. How an agent should behave is configuration. These aren't the same problem, and storing them the same way is why most AI memory feels unreliable.
Memory systems
Architectural planes
Source of truth per fact
How is Ai1's knowledge organized?
Knowledge isn't merged into one giant store. It's federated. One plane answers "what is true" with exact database queries. The other answers "what do we know" with semantic search. A unified interface sits on top, so it feels like one product.
Seven systems, two planes. Exact facts resolve with structured queries. Meaning resolves with semantic search. Agent state stays small, private, and fast to load.
Where does each fact live?
Every piece of knowledge has exactly one home. A simple, deterministic rule tells the system and every agent where each fact lives. That's what makes the architecture predictable instead of a black box.
| If it is... | It lives in... |
|---|---|
| An exact, auditable number, status, or identity (hours, money, a deal stage) | Operations or CRM. These never go through a probabilistic store. |
| A documented procedure or how work actually happens | Process Intelligence |
| Knowledge a new team member would need (how the company works, who a client is in context, a hard-won lesson) | Company Brain. Open questions use semantic search; entity questions use the graph. |
| How a specific agent should behave right now (a preference, a working fact) | Agent Memory. When it matures into shared knowledge, it graduates to the Company Brain. |
| Part of what an agent is, or how it has changed | Agent Profile, modified only through a governed, human-approved process. |
| Raw feedback from a conversation | Conversational Intelligence, where it becomes structured signal, never a conclusion until reviewed. |
The governing principle: one fact, one home. The same answer is never editable in two places, and it never silently drifts.
How does the design keep token costs down?
For anyone building on language models, the two-plane split isn't only clean, it's the most economical design. The principle: route by the type of question before spending a single token of model inference.
Exact facts skip the model
"What's this client's balance?" resolves with a direct query. Instant, exact, no inference cost. Most factual questions never invoke a language model at all.
Semantic retrieval stays in one place
Embeddings live only in the Company Brain, never duplicated across the structured systems. The expensive retrieval path is confined to one well-tuned system, and metadata filters narrow the set before search runs.
Compact context, not document dumps
Agents load a few hundred tokens of structured fields, not thousands of tokens of narrative. Stable configuration is cached, so repeated calls pay near-zero for static context.
Heavy work runs off the hot path
Model-driven analysis, like feedback distillation and process mining, runs as scheduled background work. Interactive responses stay snappy while deep analysis happens quietly.
A System That Improves Itself, Safely
The memory systems are the substrate for agents that learn from real feedback and propose their own improvements, with a human approving every change. There's exactly one manual step in the loop, and it's the approval gate.
An agent's behavior can only change through this one governed path. Continuous auditing catches anything that tries to bypass it. You get agents that learn, without ceding control of what they do.
Security at the data layer
How is client data kept isolated and accurate?
- Per-client isolation. Every client runs on a dedicated, single-tenant deployment with their own database and their own boundary. No shared data pool.
- One source of truth. Each fact has a single authoritative home. Every other copy is a clearly labeled, read-only projection.
- Governed and labeled. A controlled vocabulary classifies every record by type, source, and sensitivity, enforced at every write path.
- Drafts until confirmed. Anything produced by a language model is treated as a draft until a human confirms it.
MCP-native
Query It From Where You Already Work
The Company Brain is exposed through the Model Context Protocol, so a team already working in Claude Code, Claude Desktop, or any MCP-compatible tool can securely query the organization's knowledge from where they already are. Same authentication, same access controls, applied everywhere.
The memory system isn't a walled garden. It's an open, standards-based knowledge layer you can build on.
Slack
Notion
HubSpot
Gmail
GitHub