What should an agent do the moment it connects to your memory — before it writes a line of code, drafts an email, or touches anything you care about?
We think the answer is two things. Learn your rules. Load your context.
Vertiso Memory (vmem) has answered both since day one. Over the last two releases we sharpened that answer — and then made it effortless. This is the story of that arc: how a handshake that already worked became a single call that hands an agent your rules and your context together.
The primer, edited
Every session with vmem starts with a handshake: the agent calls
hello, and we hand back a primer — who you are, what you're working
on, what's open, how to reach the rest of your memory.
That primer earns its keep. It is also a piece of writing, and writing for models rewards the same discipline as writing for people: the most valuable line should be the most visible one. As the product grew, the primer had accumulated everything worth saying; release 1.2.0 was the editorial pass that put it all in order of value.
The test we now apply to every line of it: could a reader — human or model — find this instruction at a glance? If not, it moves up or it moves out. The line that moved up the furthest was the one that matters most: before any work, recall the user's rules for this task, scoped by the task's tags. A named imperative now, not a sentence in the crowd.
Tags are safety, not decoration
That word — scoped — earned its place with evidence.
Before teaching the recipe, we validated it against a real, lived-in account: thousands of memories, hundreds of rules, many projects. The tag-scoped query returned exactly the rules for the task at hand. The unscoped control returned something more interesting: a mandatory rule from a different project that flatly contradicted the right answer for this one.
That is exactly the failure the design guards against. An agent that obeys the wrong law is not being careless — it is being obedient to a retrieval mistake. Scoping rules by the task's tags is not a relevance nicety. It is the difference between "follow a rule" and "follow the correct rule for this context."
The same probe sharpened storage, too. People tag the note, not the seventeen facts inside it. So tags applied to a memory now flow down to every fragment we cut from it, and scoped retrieval matches how people actually tag. The machinery agrees with the habit.
Correct becomes effortless
By 1.2.0 the contract was clean: two imperatives, two calls. Check constraints. Recall context. Then work. It worked exactly as designed.
But we build for how agents actually behave, and agents economize. When the context window tightens or a task looks simple, preamble is the first thing traded away. The way to make a right step reliable is not to ask for discipline — it is to make the step free.
So in 1.3.0 we collapsed the two calls into one. recall — the call
every agent already makes — now takes an include argument:
{
"query": "What have we decided about the casper rollout?",
"filters": { "tags": ["project:casper"] },
"include": ["constraints"]
}
One round trip returns the synthesized answer with its evidence — and, leading the payload, the rules for this task:
{
"constraints": {
"rows": [
{ "memory_id": 31882, "pinned": true, "importance": "mandatory",
"body": "Casper deploys are Fridays-only." }
],
"count": 12,
"showing": 8,
"more": "call recall with types:[\"constraint\"] and the same tags"
},
"answer": "...",
"facts": ["..."]
}
Turn zero is now one call: rules and context together, before any work.
What the rules section refuses to do
The interesting design decisions are the refusals.
It refuses to paraphrase. Every row quotes your rule in your words. When a row is derived rather than quoted, it says so with a labeled pointer instead of passing synthesis off as the source. An agent deciding what it is allowed to do should adjudicate on what you wrote, not on our summary of it.
It refuses to hide the arithmetic. showing: 8, count: 12 means
exactly that: eight of twelve, pinned rules first, then by the grade you
gave them, and a more hint for the rest. A list that is complete says
so; a list that is not says that instead. Agents act on what they're
told, so we tell them the truth.
It refuses to be buried. The section leads the payload. If a client truncates the response, the rules are what survive.
It refuses to be mandatory. synthesis: false skips the answer
entirely when you want raw facts. include is opt-in. Defaults stay
boring; the one-shot is there when the agent wants it.
Future-proofing the fine print
Every release here runs a gauntlet — human review, automated review, adversarial review — and this time the gauntlet improved something subtle: the fine print.
Every tool an agent can call comes with a spec sheet that says what you
can ask it for. Ours lists constraints as the extra section recall
can include. The subtle question: should the spec say "and that is the
only value that will ever work," or simply "here is what's available
today"?
It matters because of time. We will add more sections, and agents built next year will ask for them. The server is already relaxed about this: ask it for a section it doesn't recognize and it just leaves that section out — nothing errors, everything else in the response still arrives. But if the spec sheet said "only these values," a careful agent holding last year's spec would refuse to even send the request. The strictness would live in the paperwork, not the product — and it could only ever break things.
So the spec stays open, and a test now fails if anyone tightens it back up. The rule we kept is simple: the paperwork must promise exactly what the product does — no more, no less.
Every surface, same day
include: ["constraints"] and synthesis: false shipped simultaneously
on the MCP server, the REST API, and the CLI:
vmem recall --constraints --tags project:casper "casper rollout status"
That simultaneity is policy, not coincidence. Agents reach for whatever surface is nearest — some live on MCP, some shell out to the CLI, some call the API raw. A verb that exists on one surface and not another is a silent capability gap for whoever lives on the wrong one. If it ships, it ships everywhere.
Where this goes
This is how we improve Vertiso Memory: watch the product in real hands, find the sharpest version of what already works, and ship it to every surface at once. The arc so far — make the important instruction unmissable, make it scoped, then make it free — is one loop of that process, and the loop keeps running.
Next is making your best rules ambient. Pinned rules already lead the
one-shot; we want the handful you'd staple to every session — your
honor code, your house style, your hard limits — surfaced at hello
itself, graded and pinned from any surface, so turn zero starts with
your constitution already on the table.
It's all live in 1.3.0. Connect an agent, ask for your rules, and read what comes back. If you find the next sharpest version, tell us — that's the loop working.