Hindsight vs MemoryRouter: Who Answers the Question?
Hindsight's reflect returns an answer, while MemoryRouter's reflection tools write reusable memories. Treating those as the same operation will give you the wrong integration plan.
Hindsight supports both retrieval and memory-backed answers. I built MemoryRouter to supply context to the agent that already owns the conversation.
Hindsight can do the answering
According to the current Hindsight Reflect documentation, reflect runs an agentic loop over a memory bank. It searches with multiple retrieval tools, applies the bank's disposition settings, and returns a synthesized response written by an LLM.
That is useful when your application wants a memory-backed answer without building the investigation loop itself. The response can include a structured JSON view. Enable include.facts to get a based_on object naming the retrieved sources used, or include.tool_calls for an execution trace. Those are optional response fields, not evidence you should assume arrived with every answer.
You do not have to use that answering loop. Hindsight also has recall, which returns retrieved memories for your own agent to reason over. Choosing Hindsight does not require handing it the final response.
MemoryRouter leaves the answer with your agent
MemoryRouter search returns memories. The prepare endpoint packages retrieved context for the next turn. Your agent uses that context to answer; neither call is a request for a separate memory agent to investigate and write the final response.
Consolidation is a different job. It creates material that future searches can retrieve. MemoryRouter checks out source memories, your model writes the reflections, and commit stores them above the source tier. Raw memories remain available beneath the reflections.
The reflection API documentation specifies that MemoryRouter does not call a model provider for consolidation. The caller supplies the inference. That gives you control over which model writes the stored interpretation, but you must provide that step yourself or use a connector that runs it.
Compare matching operations
| Job | Hindsight | MemoryRouter |
|---|---|---|
| Give my agent relevant context | recall returns retrieved memories |
Search returns memories; prepare builds a context block |
| Investigate and answer a question | reflect runs the reasoning loop and returns a response |
Your host agent reasons over retrieved context |
| Maintain reusable synthesized knowledge | Observations and mental models | Caller-written tier 2 and tier 3 reflections |
| Check what supported the synthesis | Optional based_on, plus mental-model provenance |
Inspect follows stored reflection lineage to source batches |
Hindsight's durable knowledge deserves separate consideration. Its mental models are stored answers to questions you define, with refresh behavior and versioned source provenance. They can move work out of the request path.
MemoryRouter's tiers organize raw records, reflections of events, and higher-level context in one vault. Search can blend those tiers or filter them. The resulting memories still go to the agent that owns the conversation.
Choose the responsibility you want to own
For a briefing over stored project history, Hindsight's reflect response can be the deliverable. Evaluate its reasoning budget and request the source fields your application needs to show alongside that briefing.
Hindsight's reflect query can include current situational context. A deployment agent can also use Hindsight recall or MemoryRouter search to combine a saved release decision with its live test result. The choice is which component should reason over both.
Choose MemoryRouter when that existing agent is where you want conversational continuity. Claude Code and Codex have hook packages for automatic conversational capture and recall. Other clients can use the MCP connection, where tool use remains model-directed rather than guaranteed on every turn.
For an API integration, budget separately for memory operations and the model work your application performs. "The memory service does not run consolidation inference" does not mean that writing reflections consumes no inference.
Test the answer and the stored memory separately
Use a harmless project decision with a reason attached. Save it, open a fresh session, and ask why the decision was made without putting the reason in the question. Verify that retrieval ran and returned the relevant source.
Then test consolidation as its own operation. With MemoryRouter, commit a reflection and inspect the resulting entry. Inspect links it to the checked-out source batch, not a model-selected citation for each sentence. A fluent summary is not proof that every sentence follows from every source in that batch.
The MCP guide documents consolidate_memories, commit_reflections, and inspect_memory. Use those tool results to distinguish an answer your agent just wrote from memory it actually saved for the next session.
Create your MemoryRouter vault and verify one saved decision from a fresh session.