The knowledge graph knows what exists; the context graph is what this decision needs — scoped at runtime, small enough to reason across, not search through.
The missing word between having structure and using it. A knowledge graph knows what exists: thousands of nodes, every entity and relationship, stable, domain-scoped, the whole memory. That completeness is its job — and its trap. A complete graph is a haystack: you built precise structure, then forced probabilistic retrieval across all of it, making the agent search what you so carefully organized. Precision at design time, guesswork at runtime.
The context graph is the answer: not another store, but a cut. For each decision, scope the graph down to the subgraph that decision actually needs — the flight, the fare rule, the weather, the one policy that applies — assembled at runtime, discarded after. The design target is a phrase worth keeping: small enough to reason across, not search through. An agent handed a scoped subgraph reads all of it and reasons; an agent handed the whole graph samples it and hopes.
The two are complements, not rivals, and the properties pair off cleanly: the knowledge graph is stable, the context graph ephemeral; one holds what's permanently true, the other what's true for this decision in this moment; one is curated at design time, the other assembled at runtime; one is enterprise memory, the other a working set. Skip the first and there's nothing sound to cut from. Skip the second and the soundness never reaches the decision.
If you run a structured personal system, you already do this without the name. The vault is the knowledge graph; every session works from a slice — the routing file points at the relevant domain, the day-folder supplies the moment, and the assistant reasons over a context small enough to actually hold. Big structure exists so that small, relevant context can be cut from it per task. That's the whole design: build the haystack deliberately, then never hand anyone the haystack.