At 11pm, a potential client lands on your site ready to buy. They ask one clarifying question. The AI answers with yesterday's price and forgets they already qualified yesterday. Sale lost.
Most sites that claim to have "AI memory" just paste the entire chat transcript back into the next prompt and hope nothing embarrassing surfaces. That is not memory. That is a liability with a search box.
A real memory system has to answer two different questions honestly: what happened with this visitor, and what is the business actually sure is true. Conflating the two is how a chatbot ends up repeating a stale price to one visitor and forgetting a completed booking with another.
Two memory systems, not one
BrainSite splits memory into two separate jobs instead of one undifferentiated log. Conversation Memory tracks the thread of an interaction. Knowledge Memory governs the facts an agent is allowed to treat as true. They run on different rules because they fail in different ways.
| Conversation Memory | Knowledge Memory | |
|---|---|---|
| Job | Tracks the thread of an interaction. | Governs the facts the agent is allowed to treat as true. |
| When it fails | Forgets context. Annoying, but recoverable. | Treats a guess as fact. That's a liability. |
Conversation Memory: four levels, not one blob
Suppose someone visits a consultant's BrainSite and explains that they run a five-person company, need help with hiring, and prefer a call next Tuesday afternoon. That is not one fact to store. It is four different kinds of state, each with its own rules:
| Layer | What it does | Why it matters to you |
|---|---|---|
| Turn context | Current message plus a bounded window of recent history, enough to answer coherently inside the active exchange. | No more repeating "what's your pricing?" five times in one chat. |
| Conversation record | The stored thread, captured lead details, qualification progress, and booking or handoff outcome, tied to one conversation ID. | Nothing about a lead's stage or answers gets lost mid-conversation. |
| Conversation resume | A scoped, pseudonymous browser identifier tied to that specific agent and site origin. Not a cross-site tracking identity, and it cannot resume a conversation from a different agent or origin. | A visitor who browsed at 2am can pick up the same conversation at 10am instead of starting over. |
| Persistent memory | Durable recall that carries into later sessions, gated by plan and retention policy rather than on by default. | If a lead says "I prefer email over phone," the agent won't suggest a call next time. |
Underneath all four, the same rule applies: current statements from the visitor outrank older remembered preferences, and anything that affects a booking or purchase gets confirmed rather than assumed.
Knowledge Memory: an actual approval pipeline
Most chatbots skip this part entirely. Knowledge Memory is not a document dump with embeddings on top. It moves through a fixed pipeline before anything reaches a live conversation:
- Ingestion: source content is captured with provenance, meaning source type, label, origin, and timestamp travel with the fact, not just the fact itself.
- Candidate creation: new information becomes a reviewable candidate, tagged as new knowledge, a correction, a conflict, or a learning from a past conversation. Nothing skips this step.
- Review: candidates get evaluated for accuracy, audience, scope, freshness, and safety before they can influence an answer.
- Approval: approved items become eligible for retrieval, scoped to their specific agent, deployment, and tenant. Approval is a permission boundary, not a confidence score.
- Retrieval: at answer time, BrainSite pulls a small relevant set of approved items. Similarity search ranks candidates, but it never overrides approval status, scope, or tenant isolation.
- Correction and retirement: outdated facts get marked deprecated or superseded through the same review process, not deleted quietly or left to rot.
That has a real cost: a new price or policy is not live for every visitor the moment someone types it in. Review adds a delay, sometimes minutes, sometimes longer if nobody is watching the queue. A slightly stale but reviewed answer beats an instantly wrong one, but it is a tradeoff, not a hidden default.
When sources disagree, there is a fixed order
Ask enough questions and sources will eventually conflict. BrainSite resolves that with a set order instead of picking whichever fact sounds most confident: current approved deployment-specific knowledge first, then current approved business context, then processed public-source content, and older profile text or a prior AI answer last. That last part matters more than it sounds: the runtime is not allowed to treat its own earlier answer as proof that a claim is true. An AI repeating its own guess back to itself is not verification.
The system is built to say "I don't know"
When a visitor asks something the approved knowledge can't answer safely, BrainSite doesn't improvise. It records the gap, deduplicates repeated versions of the same question, and surfaces it to the owner. That gap only becomes usable knowledge after it runs through the same review and approval steps as everything else. The same caution applies to what the agent picks up on its own: a memory that absorbs every conversation without review isn't a feature, it's a slow-motion mistake. Corrections and conflicts are never auto-approved, no matter how confident the system sounds. One conversation that closed well doesn't get to rewrite what the agent believes for everyone else.
Some things don't even make it that far.
What memory is not allowed to keep
Passwords, API keys, payment data, and unrelated private information are excluded from memory outright, not filtered after the fact. A deletion request outranks an active sales conversation. Memory stays scoped by owner, agent, and deployment, so one business cannot retrieve another business's knowledge or conversations, even accidentally.
What this buys you at each plan
Free includes the full seven-stage sales conversation and native booking, built on turn-level and per-conversation memory, subject to usage limits. Starter adds persistent cross-session memory, so a returning visitor's context can carry across sessions instead of resetting.
The test that actually matters
Ask this about any AI website memory feature: does it help the visitor continue, while giving the business control over what the agent is allowed to believe? A transcript dump fails the second half. A system that learns silently from everything fails it worse. BrainSite is built for the version in between: enough memory to continue a real relationship, an approval pipeline before anything becomes fact, and deletion and correction rights that stay with the people who own the business.
If your site is still pasting chat history into a prompt and hoping for the best, create a free BrainSite and see what governed memory actually looks like.
