You ask your agent a question. The answer is slightly off. You point out the gap. Spotter fixes it, and that fix doesn't disappear when the session ends. Your team doesn't re-explain the same thing tomorrow. The next analyst doesn't start from scratch. The correction stays, and the work gets better from here.
That's what memory makes possible. Not just for you. For everyone who comes after.
Starting From Zero, Every Time
Most AI agents today are stateless by design. Every session begins from scratch: the same definitions re-explained, the same corrections re-applied, the same context rebuilt from nothing. The agent never actually learns your business.
The more you work with it, the more you're working for it, re-establishing the basics instead of getting to the actual question.
Agent Memory: A Growing Need
The market has long recognized this need. A dedicated category of agent memory services has emerged — mem0, Zep, and Letta among them, purpose-built to give AI agents the ability to retain and retrieve context across sessions. LLM providers have followed: Claude organizes memory per project, ChatGPT persists preferences and corrections across conversations, GitHub Copilot builds repository-level memory from coding patterns and conventions.
The promise is real. Memory-enabled agents deliver noticeably richer experiences. ChatGPT, knowing you're training for a marathon, gives you relevant nutrition advice without re-explaining your goals every session. Claude, knowing which approaches you've already tried, avoids retracing dead ends. An agent that remembers how you like to work stops feeling like a tool you operate and starts feeling like a collaborator that knows you.
But memory can also overstep. The same mechanism that makes an agent helpful can make it intrusive, pulling context from one part of your life into an unrelated question. Writer Simon Willison captured it well, “I really don’t want my fondness for dogs wearing pelican costumes to affect my future prompts where I’m trying to get actual work done.” The core issue is loss of control over what ends up in context — and why.
At a personal level, these are tradeoffs most users can manage. In enterprise analytics, they're a different category of problem entirely.
Why Enterprise Memory Is a Different Problem
In enterprise settings, the stakes of getting retrieval wrong are higher, and the sources of failure multiply.
Correct context isn't just about relevance, it's about scope. "What was revenue last quarter?" means something different depending on which data model you're querying, which team is asking, and what role they're in. The right answer for a regional sales rep is not the right answer for a finance analyst running a consolidated view. Memory needs to know not just what it has learned, but what's relevant to this question, on this data, for this user.
Different users carry different, sometimes conflicting, definitions of the same thing. Finance and sales may both have a version of "revenue" in memory. A product team's definition of "activation" may not match the growth team's. As organizations grow, so does the surface area for definition collision. Memory that accumulates without governance makes these collisions invisible rather than resolving them.
And the underlying business never stays still. Schemas evolve. KPI definitions get updated. A business process that was accurate last quarter may be deprecated today. Memory that was correct six months ago can quietly degrade answers, and without visibility into what was retrieved, neither the analyst nor their manager can tell when it happened.
Getting retrieval right, fetched for the correct query, scoped to the right context, governed across users and teams, and kept current as the business evolves, is the hard problem. It's also what separates a memory system built for enterprise analytics from one that just happens to work at a smaller scale.
How Spotter Memory Works
Spotter is built to be your most capable analytics companion, one that doesn't just answer questions accurately, but understands the business context behind them. The gap between a highly capable but contextless agent and one you'd actually trust with your most important questions isn't intelligence. It's accumulated knowledge.
Think about how a skilled analyst grows into a trusted partner. They start with strong fundamentals: the right tools, domain expertise, and analytical ability. On day one, they're given documentation, the data dictionary, the KPI definitions, and the dashboards the team trusts. That's enough to get started. But what makes them genuinely valuable over time is different: they've learned how your business defines success, which metrics actually matter for each team, and which answers consistently get things right. They've absorbed corrections from a dozen stakeholder conversations. They've noticed which cuts of data get used and which get ignored. That knowledge doesn't come from any manual. It builds through work, and it's the thing that turns a capable hire into an indispensable partner.
Spotter Memory is how we close that same gap for your AI analyst.
Spotter's Knowledge Sources
Liveboards: Spotter observes the queries, metrics, and patterns in your Liveboards and builds an understanding of your data from them. The work your team has already done becomes formalized knowledge, automatically. You don't start with a blank slate.
Conversations: When you correct Spotter or share context mid-conversation, it remembers. No special mode, no detour to a settings page. The correction happens exactly where the gap surfaced, and it stays.
Connected sources and uploads: You’re not limited to what already lives in ThoughtSpot. Point Spotter at trusted knowledge sources like Confluence, SharePoint, or internal wikis, and it pulls your business definitions and process documentation directly from there. Drop a CSV into the conversation, and Spotter absorbs it immediately, no pipeline required.
Rules and Recipes
What Spotter learns is organized into two kinds of knowledge: Rules and Recipes.
Rules are business definitions: what your metrics mean, which events count toward which measures, what should or shouldn't be included in a calculation. Rules keep answers consistent, no matter who's asking.
Recipes capture how Spotter arrived at a correct answer: the specific query path, filters, and logic it followed. Where Rules define what's true, Recipes make sure Spotter can replicate a known-good answer reliably, rather than re-deriving it from scratch each time.
Together, they're what a skilled analyst carries: what's true, and how to get there.
How Spotter Gets Scoping Right
Knowing what to learn is only half the answer. The harder part is knowing what to retrieve, and when. Spotter Memory is organized in layers, and the layer that activates depends on the context of the question being asked.
At the data model level, memory captures the rules and patterns specific to that data model. When a query runs against your CRM data, Spotter retrieves memory tied to that data model, not memory from an unrelated financial or operational one.
At the personal level, Spotter remembers what's specific to you: your working preferences, the corrections you've made that reflect how you personally think about the data. These apply to you when you're working. They don't propagate as shared definitions, and they don't overwrite how the organization has defined its metrics.
When both layers are relevant, both activate. When only one is, only that one applies. The result is memory that's useful rather than noisy, and answers that get more precise as the system learns more, not less reliable.
Your personal layer also means Spotter starts to feel like your analyst, not a generic one. The slice of pipeline you always look at first. The way you filter cohorts. Your shortcuts, available every time you come back.
Memory You Can See and Manage
All of this is only trustworthy if you can see it, and fix it when it's wrong. An agent that learns silently is an agent you can't correct. Spotter Memory is designed to be transparent.
What Spotter has learned is visible. You and your team leads can review the knowledge it's built, see which rules are applied to which data models, and correct anything that's wrong. When something is outdated or incorrect, it can be updated. The institutional knowledge stays accurate because it stays editable, not because the system assumes it always got it right.
Security Built In, Not Bolted On
Memory compounds knowledge. It shouldn't compound access.
Spotter ensures that at query generation time, users only see data they're authorized to see. Row Level Security and Column Level Security are honored in the layer where data is retrieved and surfaced, not worked around. A user whose access doesn't include a restricted column won't receive answers derived from it, regardless of what's in memory.
The intelligence compounds. The permissions don't change.
At enterprise scale, that isn't a nice-to-have. It's the condition for your agent being allowed to deploy at all.
From Day One to Trusted Analyst
The hardest part of deploying any AI tool in an enterprise is the cold start: the gap between "installed" and "actually useful."
Spotter Memory is designed to close that gap from day one. You're not waiting months for memory to accumulate. You begin with an analyst that already understands your data, and every conversation from there makes it better.
The analyst that starts as capable becomes, over time, the one the team actually relies on. The one who knows which cut of pipeline data matters for the Monday call, which definition of revenue is being used in the board deck, and how to get to a trusted answer without being re-coached from the beginning.
The semantic layer tells Spotter what your data means. Spotter Memory tells it what your business means.
Together, they form the foundation for an AI analyst that doesn't just answer questions accurately, but understands the business it's answering them for.
Request a demo today to see what Spotter can do for your team.
