Give your agents
a mind.
Not a memory layer bolted onto a vector DB. A structured memory architecture — facts, moments, relationships, tasks — built for agents that need to remember like a brain does.
“Agent memory” has been oversold.
Most agent memory layers do one thing: they take your messages, embed them, store them, and hand back the nearest neighbors at query time. That’s useful. It’s also not memory — it’s search over a log.
Memory has structure. A fact is not a moment. A moment is not a relationship. The thing an agent did last Tuesday is different from the thing that is generally true. Collapsing all of that into a single vector index is how you end up with agents that can quote themselves back but can’t tell you what they were working on.
Vero Memory treats those as different primitives. First-class episodic memory with temporal decay. First-class semantic facts. A real relationship graph. Task state the agent can query. Shared memory across multiple agents in a session. One API, structured around how cognition actually works — not around how embeddings happen to be cheap.
Seven memory types.
One brain.
Semantic
— what's trueLong-term facts your agents know and trust. “Drew prefers concise updates.” “Acme ships on Fridays.” Permanent. Retrieved by meaning.
Episodic
— what happenedCompressed summaries of past conversations and events, with a 30-day half-life. Recent experience weighs more than ancient history — automatically. Your agent remembers yesterday before it remembers last quarter.
Graph
— what's connectedEntities and the relationships between them, stored in a real graph database (Apache AGE), not flattened into text. Alice works at Acme. Acme has three projects. Project X is blocked on Task Y. Traversable at query time.
Plus working memory, tasks, artifacts, and a full knowledge base for RAG.
Retrieval that earns its answer.
When an agent asks for context, it doesn’t just get the top-k nearest vectors. It gets a pipeline — hybrid search, temporal decay, diversity re-ranking, and a token budget — assembled into the most useful context for the query at hand.
The only memory service built for multiple agents.
Most memory services assume one agent, one user, one history. That model breaks the moment you run more than one agent on the same problem.
Vero thinks in sessions. Multiple agents can join a session, write to shared memory, read what the others are doing, and subscribe to a real-time event stream. Agents coordinate through what they know, not what they say — we call it telepathy-first communication. The researcher writes a finding; the writer reads it without a handoff message. The editor subscribes to changes and reacts in real time.
If you’re building a single agent, this is a bonus. If you’re building a team of agents, it’s the whole product.
- Shared session memoryWriteShared / ReadSharedInter-agent state without a coordinator
- Real-time event streamSubscribe + GetEventsSSE stream with catch-up on reconnect
- Cross-agent context framesGetContextFrameSituational awareness of what others did
- Queryable task graphGetSessionTasksPending, in progress, blocked, done
One API. REST or gRPC.
No adapters.
curl -X POST https://memory.veroagents.com/brain/agent_123/facts \
-H "Authorization: Bearer $VERO_KEY" \
-d '{
"fact": "Drew prefers concise updates",
"user_id": "drew"
}'What “agent memory” actually means.
| Vector DB | Typical memory layer | Vero Memory | |
|---|---|---|---|
| Semantic facts | Manual | Yes | Yes |
| Episodic memory with decay | No | Partial | 30-day half-life |
| Relationship graph | No | No | Apache AGE + pgvector |
| Task state as memory | No | No | First-class |
| Multi-agent sessions | No | No | Core primitive |
| Shared memory across agents | No | No | Telepathy-first |
| Knowledge base + RAG | Manual | Sometimes | Built in |
| Hybrid search + MMR + decay | Manual | Basic top-k | Full pipeline |
| Real-time event stream | No | No | SSE + catch-up |
If your memory service doesn’t do half of these, it isn’t a memory service. It’s a search index with a logo.
Built for agents that actually do things.
Customer-facing agents
That a customer called twice last week. That their account is flagged. That their preferred rep is out of office until Friday. One GetContext call. No RAG-over-everything-and-pray.
Teams of agents
A researcher, a writer, and an editor sharing one session. Shared memory, a common task graph, and a live event stream. They don't re-discover the same things three times.
Long-running autonomous agents
Episodic memory decays gracefully. Tasks persist across restarts. Facts accumulate. The agent gets smarter about the project over time — not more confused.
The waitlist is open.
Vero Memory is in early access with a small set of design partners. If you’re building a serious agent system — single or multi-agent — we want to talk.
- API access as soon as your account is provisioned
- A month of Pro-tier usage included
- Direct line to the team building it
- First look at SDKs, MCP integration, and self-hosted builds