Hindsight Models for Agent Memory: What Each Does
Nov 4, 202612 min read
Hindsight models are decision, rerank and embedding models that Vectorize trained for its Hindsight agent-memory product, the kind of memory layer that agents built in workflow tools like Activepieces can draw on. Vectorize released them as a new family, served through Hindsight Inference.
Agent memory is the capability that lets an AI agent store, retrieve and reuse information from past interactions, which Hindsight handles by using its decision, rerank and embedding models to decide what to keep and which memories to surface.
The family's new, and every fact here was read on 2026-11-04 from Vectorize's pricing page and the Hindsight docs.
By Vectorize's description of Hindsight Inference, the whole switch is a change of base URL, the web address your app sends its model requests to: the models behind Hindsight's own retrieval, served to your apps directly.
For an auditor, that raises the first question: who owns the base URL and the key behind it?
Hindsight models launched: what Vectorize released and when
Three models are named: hs-decide-1-flash, a decision model, hs-rerank-1, a rerank model, and hs-embed-1, an embedding model. All three are served through Hindsight Inference, and you switch to any of them by changing a base URL.
The three types do different jobs in agent memory. An embedding model turns text into vectors, lists of numbers that let the system find stored items by similarity of meaning.
A rerank model takes the candidates that search retrieves and re-orders them by how relevant they are to the question. A decision model decides what the agent should store, update or retrieve.
Each needs its own check before you rely on it, and the prices listed later buy these three jobs.
Confirm both on the vendor pages before any pilot, because the licence decides whether you may host the weights yourself.
"Open-weight" means the trained model files are published so you can download and run them on your own hardware, under whatever licence terms come with them. hs-decide-1-flash has 0.8B parameters and Apache 2.0 open weights, hs-rerank-1 has 114M parameters and MIT open weights, and hs-embed-1 has 112M parameters and MIT open weights.
Everything below works on Activepieces' free plan. Start without code or a credit card.
Why agent memory matters to teams automating work
When an agent forgets between runs, your team carries its context for it, every time. Each run starts blank, so whoever owns the workflow must decide what the agent needs to know and supply it again.
That person also owns the connection to the apps involved, and the agent can only act within the access that connection grants.
It shows up in four ways in practice, each a recurring cost rather than a one-off glitch:
- Context is re-pasted into each prompt, so the same background gets copied in on every run.
- Questions already answered get asked again.
- Earlier decisions are lost, so a choice made on Monday is not honoured on Thursday.
- Outputs are inconsistent, because each run reasons from a different slice of the history.
Someone has to maintain the pasted context, and someone has to catch the contradictions it fails to prevent. Those four add up to manual upkeep that grows with every workflow you automate.
The obvious fix is a memory layer, meant to take over that carrying: the agent keeps what it learned and draws on it next time.
That's the problem Vectorize aims Hindsight at, and the vendor's own pages are the only place to confirm how far it goes.
What Vectorize confirms about Hindsight models
I claim no figure beyond those quoted here, and the confirmed figures live on the vendor's pages.
Vectorize makes Hindsight, a memory layer for AI agents, and the Hindsight models are its new release. On the BEAM memory benchmark, as reported by SurrealDB, a database vendor and not the maker:
Test on your own history length.
I have no confirmed access route to quote. Before connecting anything, name who owns the credential and what scope it carries, and take both from the Hindsight docs.
The price is $0.02 per million input tokens.
Those ratios are the largest observed, so treat them as a ceiling and measure your own pilot workflow against them.
Hindsight model accuracy reported by Vectorize
We haven't run any of these accuracy figures ourselves. They are the maker's own published claims for Hindsight, so read them as a starting hypothesis for your pilot rather than a result.
On LongMemEval, a long-conversation memory benchmark, Vectorize compares four memory approaches, and the Hindsight models come from Vectorize and target agent memory. Hindsight and Zep, another memory product, land nearly level, while feeding the full context to the model trails far behind.
So the claim's that a dedicated memory layer beats brute-force context, not that Hindsight clearly beats every rival.
Ask who owns the connection before you trust any number. Name whoever holds the Vectorize API key or the open-weights download, and have that person read the benchmark pages under their account.
Check the maker's pricing page for the hosted API. If you run the open weights yourself, the cost's your own compute, so measure that during the pilot.
Connecting hindsight models to a workflow today
Connect through an HTTP request, an OpenAI-compatible provider setting, or an MCP server, a service that exposes tools to AI agents through a common protocol. Price each route by who holds the memory, because that decides what you pay and what you maintain.
Activepieces has no native support for these models, but a flow can reach them by any of those routes, and the connection only has to be made once.
Once a integration is connected there, an agent can call it: the same action runs as a step in a flow and as a tool on the project's MCP server, which Claude, ChatGPT, Cursor or an agent you built can all reach, so nothing is exported and nothing is wired up twice.
That matters here because a memory connection you must rebuild for your agents becomes a second migration. MoneyGram and Moneypenny run Activepieces in production, and the integrations are MIT-licensed and open to inspect, with every integration available to an AI as an MCP tool.
Side by side, the table sets four ways of giving an agent memory. Three rows carry a published price, and speed figures are published for the reranker and embedding model, though you should still measure latency on your own workload.
| Option | Published price | Speed figure | What you manage |
|---|---|---|---|
| Context in each prompt | None; you pay your model's input rate | None published | Everything resent each call, plus trimming |
| Database storage | None; depends on your host | None published | Schema, retrieval, backups, access |
| Mem0 | Free; Starter $19/month | None published | Account, API key, data retention |
| hs-decide-1-flash | $0.02 per 1M input | None published | API key, plus compute if self-hosted |
Prices and plan limits checked against vectorize.io and docs.hindsight.vectorize.io and docs.claude.com and claude.com and openai.com and gemini.google on November 4, 2026.
At $0.02 per 1M input tokens (according to Vectorize), hs-decide-1-flash looks cheap, and output is free, but any self-hosted compute still needs metering.
Mem0's free tier and $19 Starter plan suggest a pilot can begin without budget approval, yet someone must still own the API key that connects it, so cost's no longer a barrier, but whoever owns the keys becomes one.
Before the pilot, record who holds each credential and which workflow it touches. Then time one real run, since the missing speed figures leave no vendor number to lean on.
Easier to see it running than to read about it: set it up free, no card.
Hindsight model cost and speed compared
On paper you can compare cost but not speed: Vectorize lists Hindsight Models at between half a cent and two cents per million input tokens, and publishes speed figures such as reranking 50 memories in about 1.5 s on two CPU threads.
Hindsight pricing against current memory options
On Vectorize's pricing page, three prices are listed:
Even the dearest of the three costs two cents to read a million tokens, so memory lookups stop being the budget line you worry about.
Passing full context in every prompt means paying your language model's input rate on the whole history, every call. On SOTA2's shared LongMemEval test:
- that approach with GPT-4o scored 60.2% accuracy
- Hindsight scored 83.6% accuracy: - Zep scored 83.3% accuracy
- Mem0 scored 79.5% accuracy (both are rival memory tools)
You would pay more and get the weakest result.
Until you measure it, any claim that they beat a database lookup stays unsupported, because Vectorize publishes no latency or throughput figures for these models.
There is no independent head-to-head test, and no database-storage cost is published to set beside the prices above. Assign one named owner to watch these:
- Changelog entries for new model versions
- Docs pages for new integrations
- Changes to the $0.02 input rate
- A full per-model cost table on the blog post
Until those appear, treat the table of rivals as a gap to monitor, not a settled ranking.
What to verify about Hindsight models
Check the maker's changelog, documentation and pricing page for answers to the questions below, then pilot on one workflow. Until those pages answer them, everything else is inference.
Whatever the pages leave blank stays an open item in your handover notes, not an assumption. The questions below are the ones they should settle:
- What exactly are hindsight models, in the maker's own definition?
- Who makes them, and who answers for support?
- Are the weights open, and under what licence terms?
- Does a ready-made integration exist for your automation tool?
- Has any independent head-to-head test been published?
Between them, these answers decide how much of the pilot you can build on the maker's word and how much you must verify yourself.
For the pilot, choose one workflow where a wrong memory costs little. Before connecting anything, name the person who owns the connection, and record the token type and the narrowest permission scope that works. Start read-only, so the agent can recall but not change records.
Log what the memory layer returns against what a person would have retrieved. Because that comparison comes from your own data, it's the only evidence here you can trust fully.
What Activepieces does about this
Activepieces has no native integration for Hindsight models, and I'd rather say that plainly than imply otherwise.
What it gives you is the general building blocks the rest of this article leans on: an HTTP request step, which can call the base URL Vectorize documents for Hindsight Inference, and a flow around it that you can run today.
Nothing here needs the vendor to ship an integration first, and nothing about the pilot has to wait on one.
The part that matters for the ownership question is where the connection lives. In Activepieces you create it once, with its own key, and the same action runs as a step in a flow and as a tool on the project's MCP server.
Claude, ChatGPT, Cursor or an agent you built can reach it from there. So the dedicated, narrowly scoped key and the named owner you set up for the pilot are a single connection to rotate or revoke, not a copy in every agent.
That is the difference between a memory layer you can hand over and one that quietly becomes a second migration.
On licence and track record, the facts we can point at are these. The integrations are MIT-licensed and open to inspect, so you can read exactly what a step sends before it touches your data. MoneyGram and Moneypenny run Activepieces in production.
None of that says anything about how well the Hindsight models perform; that still comes from your own pilot and the maker's pages.
So the practical move is small. Build one flow where a wrong memory costs little, call the Hindsight endpoint over HTTP with a read-only, narrowly scoped key, and log what comes back against what a person would have retrieved.
Time the run yourself if you need your own numbers, since Vectorize's published speed figures come from its own setup. If the numbers hold up, widen the flow. If the vendor's pages change, you edit one connection rather than rebuilding your agents.
Frequently asked questions
Because your own data can't settle the questions below, these answers rest only on what the maker has published.
Aimed at AI agent memory, they were released by Vectorize. Treat the maker's own announcement and documentation as the source of record. Anything a third party says about capabilities should be confirmed there.
Confirm any support claim against the platform's own integration listing before you build on it. The dedicated section on that platform covers this in full.
How do I add memory to an AI agent workflow today?
Use general building blocks: an HTTP request step or a custom API call from your automation tool to the vendor's documented endpoint. Before you build, settle two things, in this order:
- Create a dedicated API key with the narrowest scope the vendor offers, rather than reusing a personal key.
- Name one person as the owner of that connection, so someone's accountable when the key needs rotating or the vendor changes its interface.
Then pilot on a single workflow, not several.
Check Vectorize's own pricing page and documentation, and ask the vendor in writing if the page's unclear.
Pricing's set by the maker and can change, so a figure quoted elsewhere may be out of date. During the pilot, record actual usage so you can compare it with the published terms.
