Zep vs Vilix AI: picking agent memory without the marketing

Your nightly automation triages tickets. Your coding agent builds the feature. Your planning chat on the phone holds the decisions. All three wake up with total amnesia, and someone told you "just add a memory layer." Two names keep coming up: Zep and Vilix AI. They are not interchangeable. This is the breakdown without the marketing: what each one is actually built for, where each wins, and the one-line decision rule.

Zep, in plain terms

Zep is a temporal knowledge-graph memory for agents you build. The engine is Graphiti, its open-source project (Apache-2.0, ~25-30K stars), and the core idea is that facts change: a client's launch moved from Q2 to Q4, and the agent needs the current date while still being able to answer "what was it in Q2?"

Every fact in Zep carries two timestamps: when it was true in the world, and when the system learned it. When a new fact contradicts an old one, Zep doesn't overwrite. It closes the old fact's validity window, so history stays queryable. That is genuinely the best model in the category for temporal reasoning, and it shows in their benchmark numbers (94.8% on DMR, solid LongMemEval gains).

You integrate it with REST or SDKs (Python, TypeScript, Go) inside your app's code, per project. There's a managed MCP server with seats sold per pricing tier, and Graphiti ships its own open-source MCP server. Retrieval is hybrid semantic plus BM25 plus graph traversal with no LLM in the retrieval loop, returning pre-formatted context blocks for prompt injection. Latency is a real strength: P95 under 300ms.

The costs: Zep's production entry is Flex at $125/mo for 50,000 credits, with every memory operation consuming credits and overage auto-top-ups at $25 per 10,000. There is a free tier (10,000 credits/month), but for a high-volume scheduled agent, the credit math compounds. Also note the self-host story: the old Zep Community Edition is deprecated, so "self-host" now means running Graphiti yourself with your own graph database, LLM keys, and Docker. Doable, but users report real integration effort to reach cloud-level performance.

Vilix AI, in plain terms

Vilix AI is a hosted shared memory and work-state layer that attaches to tools you didn't build. Connect each tool once (OAuth, or an API key over MCP for headless agents like Hermes or OpenClaw), enable the memory tools, and the same memory follows you: Claude, Codex, Cursor, OpenClaw, Hermes, Grok, Manus AI, GitHub Copilot, Windsurf, Lovable, Muse, anything MCP-compatible.

Two things are different about the model:

Full conversations, not distilled facts. Zep runs your exchanges through an LLM on the write path and stores extracted entities and relationships. Vilix AI stores the actual full exchanges with source metadata, so you can revisit the real conversation, not just what an extraction pass decided was worth keeping. When you need to know why a decision was made or what your agent actually did on last night's scheduled run, full history is more faithful. It's a bigger store; that's the tradeoff.

Memory plus work state. Projects, tasks, personal and project rules, reusable agent skills, an agent inbox, editable from any connected tool or the dashboard at app.vilix.ai. Retrieval is semantic plus keyword (so exact strings like order IDs match literally), recency-aware, with last-write-wins conflicts: correct something once and every tool sees the update.

The costs: flat pricing. Starter $10/mo, Pro $20/mo, Power $49/mo, free plan, 7-day Pro trial with no credit card. The honest tradeoff, stated upfront: cloud-only. No self-host option, no open-source server. Your data is portable (export everything or delete it anytime, per-user isolation, no training third-party models on your memory), but portability isn't self-hosting.

So who should pick which?

Ask yourself one question: am I building agents, or am I operating them?

Pick Zep if you're building agent software. Your app calls the API, your code decides what gets saved and recalled, you want per-project memory, temporal reasoning about facts that evolve, and you can afford $125/mo or have compliance needs (SOC 2 Type II, HIPAA on Enterprise, BYOK/BYOC). Zep is the enterprise-positioned product in this space, and its temporal model is the real reason to pay.

Pick Vilix AI if you're operating agents across tools you didn't build. The nightly n8n run, the Claude Code session, the headless runner, the planning chat: one memory, shared by default, no per-app wiring, zero infrastructure to manage. $20/mo flat instead of credit-metered billing.

Pick Graphiti OSS if you're an engineer who wants Zep's engine for free. It's Apache-2.0 and actively maintained. Just price your own ops time (graph DB, LLM keys, the integration gap to cloud parity) against $125/mo before romanticizing it.

And if you're in the market at all, there's a whole thread of people comparing these exact tools — worth reading before you commit to a billing model.

The unsexy truth: most of the regret in this space comes from buying a developer platform when you needed an operator tool, or vice versa. Match the job description, not the hype. If the shared-memory model is what you need, Vilix AI starts free, trials Pro for 7 days with no card, and lets you leave with your data anytime.