An AI agent is only as good as the context it works from. Give it a pile of documents and a question, and it has to do everything at once: find the right material, read it, and reason over it, all while you wait. Give it structured, verified context up front, and it can spend its time on the actual work.
"Context graph" has quickly become the industry's name for that idea, and it is being used to mean different things. Venture investors describe context graphs as accumulated decision traces: a searchable record of why an organization decided what it decided. Enterprise software vendors describe graphs of workplace activity: who edited which document, how tickets get resolved, how work flows through a company. Both are useful. But for the professionals AlphaSense serves, the decisions that matter are about markets, companies, and capital — and the context they need is overwhelmingly about the world outside the enterprise, fused with the firm's own judgment.
So when AlphaSense says context graph, it means something specific and more demanding: the working context an always-on agent runs on when the answer has to be right. It sits on top of a knowledge graph, and the two do different jobs. A knowledge graph turns unstructured documents into structured, verified knowledge. A context graph turns that knowledge — along with the tools an agent can call, the skills it can apply, and the memory it carries between questions — into the working context the agent operates on. The knowledge graph makes sure every fact is structured and true. The context graph lets an agent put those facts to work: decide what to ask next, remember what it learned, and show its work.
The knowledge graph is foundational to the context graph, but each layer needs to hold up in order to support a trusted, always-on agentic system like SuperAnalyst.
Two Ways to Answer a Question
Let’s start with an example that illustrates how the knowledge graph is built and why it can be relied upon. Consider a question an analyst might ask: What is Apple's supply chain exposure? There are two ways an AI system can answer it, and they are not equally reliable.
The first is standard retrieval-augmented generation (RAG). The system runs a semantic search, pulls the documents most likely to mention Apple, and hands them to a model that reads for relevant passages and writes an answer. This works for a lot of questions. But the answer rides on three unverified steps at query time: which documents surface, which passages the model picks, and whether it synthesizes them correctly. Each step is a place the answer can drift from what the sources actually say, and nothing checks any of them before the answer reaches the user.
The second uses a knowledge graph. Here the question is informed by a structured lookup rather than answered by one. Apple is an entity, and its relationships to other entities (suppliers, component categories, geographies, contract terms) are already resolved and stored as connections in the graph. Before the agent decides how to research the question, it starts from a verified view of Apple's supply chain instead of assembling one from scratch. Search is still involved, but it runs on top of structured, trustworthy ground rather than in place of it.
In the RAG-only approach, all of the work happens at query time. In the knowledge graph approach, the expensive part happens once, at ingestion, so it never has to be repeated under the pressure of a live query.
What Makes the Graph Trustworthy
AlphaSense's graph began with classical machine learning: fast and accurate enough for entity recognition, relationship extraction, and sentiment scoring at scale. Large language models lifted that ceiling. They resolve the ambiguous cases classical models could not, and they made harder problems tractable, including mapping multi-tier supply chains and imposing structure on the unstructured client-uploaded content like investment memos, board decks, and meeting notes.
Several layers of this work run at ingestion, and each closes a gap where ordinary search fails. Smart Synonyms mean a query for "lithium" also surfaces "spodumene" and "brine," real relationships a keyword match or even vector search alone would miss. Entity linking resolves every mention of a company to a single canonical entity, so the model does not have to reconcile name variants on the fly. Document type classification separates a board deck from a pitch deck before retrieval, and boilerplate identification strips the template language that would otherwise bury the paragraph that matters. Speaker identification keeps what an expert said distinct from what the interviewer asked, so a question is never mistaken for an opinion.
These layers matter most when they run together. A query like "what have experts recently said about lithium supply?" needs synonyms, entity linking, speaker separation, classification, and time filtering all at once. No single layer answers it. Stacked, they also save the model from working any of this out at query time, which is cheaper in tokens and stricter on completeness. That is the difference between an answer that is complete and one that only sounds complete.
The knowledge graph structure provides value in three distinct ways where document-based synthesis tends to fail. The first is direction. A relationship in the graph carries its direction as a verified property, so "Company A supplies Company B" cannot reverse because a model misread an ambiguous sentence. The second is depth. Following a chain, such as a supplier's supplier's supplier, is the same operation as following a single link, whereas a document-reading model has to find and connect a fresh source at every step and can lose the thread. The third is time. Relationships are timestamped, so it can answer as of a specific point in time; what was true in Q2 is not assumed true in Q4. Together, these are what let the graph surface component-level detail — the specific supplier risk buried three hops down a value chain — that document search alone rarely reaches.
All of this rests on one condition: the facts in the graph have to be correct. AlphaSense verifies the extraction before it lands. During ingestion, a first model pulls facts and relationships from the source, and a second, independent model checks that extraction against the same material to confirm the claim reconciles with what the document actually says. Where the two disagree, the relationship is held back rather than entered on a guess, because an incomplete graph is recoverable and a wrong one is not. The same standard applies across the layer: a direction, a sentiment score, and an entity link each have to clear the check before they can shape an answer.
From Knowledge Graph to Context Graph
A verified knowledge graph is powerful on its own, but an always-on agent like SuperAnalyst needs more than a good answer to a single question. It needs to know which tools to reach for, to apply skills across problems, to remember what it learned on the last question so it does not start the next one cold, and to leave a record of how it reached a conclusion. Those are different kinds of structure than facts, and they are what the context graph holds.
The context graph applies the same discipline one layer up. It takes the verified knowledge from the graph and combines it with the tools, skills, memory, and reasoning traces an agent accumulates, then makes that combined context available to reason over instead of rebuilt every time. The precomputed debates that decide a thesis — whether a company's margin expansion is structural or cyclical, whether its balance sheet can support its strategy — live in this layer, resolved and kept current before anyone asks. This is the context an agent like SuperAnalyst runs on.
Memory and context are easy to conflate, and the distinction is worth pausing on. Think of memory as the transcript of a long-running conversation: complete, durable, and mostly irrelevant to any single question. Context is what a good colleague does when you ask for a follow-up a week later. They don't replay the whole transcript; they recall the two decisions and the one open issue that bear on what you just asked. Memory is the record. Context is the relevant extraction from it, assembled for the question at hand — along with what no transcript contains, such as fresh evidence and the verified facts in the graph. An agent that hauls its entire memory into every task drowns in its own history; an agent with no memory starts every task cold. The context graph is the mechanism between the two: It holds the accumulated record, and it delivers to the agent only the slice the current question needs.
This is how AlphaSense’s context graph differs from others. A workflow-activity graph infers process from behavioral signals, like who touched what, in what order, and can capture only the pattern of the work, not the reasoning behind it. AlphaSense doesn't have to infer the reasoning, because in research-driven organizations it is written down: in theses, notes, memos, and the source-linked record every agent workflow leaves behind. The "decision traces" investors describe as the most valuable asset of the AI era are, in this domain, capturable by design. That is the reconciliation: same layered idea the industry has converged on — knowledge graph as foundation, context layered above it — pointed at a different and higher-stakes target, and held to a standard of verification the others don't attempt.
What This Looks Like in Practice: Reading a Value Chain Before Earnings
The clearest way to see the layers work together is a workflow SuperAnalyst runs today: the pre-earnings supply chain read-through.
Almost every covered company has ecosystem members that report earnings before it does, and those earlier prints carry signals. TSMC and ASML inform Nvidia. Foxconn's results inform Apple. Walmart's traffic informs consumer brands; hyperscaler capital-expenditure disclosures inform every AI supplier. A good analyst reads those earlier prints, the "echoes," and forms a view of the target's quarter before management says a word. Done by hand, it is days of work, repeated every quarter, and most of it is not analysis. It is finding, resolving, and remembering.
The knowledge graph supplies the map. “Who is actually in this company's value chain” is a relationship question answered from verified structure, not a fresh document hunt. Upstream suppliers, downstream customers, peers, channel partners: each relationship carries its direction, so a supplier cannot be mistaken for a customer; its depth, so the agent can walk from the target to a supplier's supplier in one operation; and its timestamps, so a relationship that ended two years ago doesn't contaminate this quarter's read. Because the expensive resolution happened at ingestion, building the map is a lookup, not a research project.
The verified evidence layer supplies the signal. The agent pulls each “echo” company's recent call transcripts, filings, conference remarks, and extracts candidate signals across the categories that move an earnings call: demand, pricing, inventory, mix, capital expenditure, lead times, bookings. Signals must be specific and falsifiable: "demand looks strong" is not a signal; a hyperscaler raising capex guidance well above expectations, with management's language shifting to "supply-constrained," is. Language that matters is captured verbatim, never paraphrased, because the signal is sometimes the exact word a CFO chose. Every claim carries a citation, and when it echoes conflict, the conflict is surfaced, not silently resolved. Time is enforced as the graph enforces it: a print that landed before the target's own last call is already digested; only what landed after carries new information.
The context graph turns it into an analyst's work product. This is where tools, skills, memory, and reasoning traces — the things a context graph holds beyond facts — stop being abstractions. The workflow itself is a skill: a codified, versioned procedure so the firm's best practice runs the same way every time instead of living in one analyst's head. The tools are the platform itself — search, financial data, document intelligence. The memory is what makes the second run better than the first: the ecosystem map persists and is refreshed rather than rebuilt; the analyst's prior thesis is loaded as an anchor, so the memo speaks the analyst's own debate language and flags which new signals confirm, strengthen, or contradict the existing view. And the reasoning trace is the deliverable: a memo that names its echo set, scores each signal on direction, confidence, and materiality, makes a net directional call, states what would invalidate it, and registers every source behind it.
Then the loop closes. After the target reports, every scored signal is graded against what management said: hit, miss, or pushed. Over quarters, the system learns which echoes are actually predictive for which targets — if one supplier's capacity commentary has called the target's data-center revenue correctly six times out of eight, it earns more weight next cycle. This is the part no query-time system can do at all, because there is nothing to grade: the reasoning evaporated the moment the answer was delivered. Every run leaves a structured, source-linked decision trace, and the trace compounds. The context graph is not just consulted by the agent — it is written by the agent, and it gets better every quarter it runs.
A RAG-only system would retrieve documents and hope the read-through was inside — no verified map, no direction, no freshness partition, no memory, nothing to grade later. A workflow-activity context graph would know which analyst writes the memo — and nothing about the supply chain itself. The read-through is only reliable when every layer is present: verified relationships to walk, sourced evidence to weigh, and accumulated context — skills, memory, traces — to reason with. That is the whole argument in one workflow.
Built Before the Question
Everything above the graph layer inherits whatever was true or false at the bottom. A context graph built on an unverified knowledge graph is a taller structure on a weak foundation; every skill, memory, and reasoning trace is only as sound as the facts underneath. That is why the verification work matters more, not less, as the system grows, and why the industry's context-graph conversation, for all its energy, keeps skipping the hard part: Context is only an asset if it can be trusted.
This is what decision-grade AI requires. Not access to more information, but a foundation of facts that were checked before they were used; a context layer that turns those facts into something an agent can act on; and an agent whose every run leaves a record that makes the next run better. It is why an answer from AlphaSense traces back to a verified fact instead of a plausible-sounding one, and why the knowledge graph, the context graph on top of it, and the agent that runs on both are worth building before the question is ever asked.
