Add memory to any AI agent with Vilix (MCP)

A tool-agnostic guide to wiring Vilix into any agent harness that accepts a custom MCP connector. One endpoint, three tools, and every agent you run shares the same persistent memory.

Any always-on agent harness that accepts a custom MCP connector can gain persistent memory in under two minutes. You point the harness at https://api.vilix.ai/mcp, authenticate once, and from that point the agent automatically loads your context before each reply and saves the exchange afterward. Memory lives in your Vilix account server-side, so every agent you run shares the same store regardless of which tool it runs in.

Why agents forget (and why MCP fixes it)

Most agent runtimes are stateless by design. Each task starts from a blank context window, and every decision, project note, or user preference vanishes when the run ends. The result is that you re-explain the same stack, constraints, and history on every invocation, or you stitch together awkward prompt injections that are fragile and hard to maintain.

The Model Context Protocol gives agent runtimes a standard way to call external tools at inference time. Vilix exposes three memory tools over that protocol. When the agent framework calls them, your memory loads and saves automatically without any custom code on your side.

The three-step memory pattern

Every Vilix-powered agent turn follows the same pattern regardless of the harness:

• get_context (before acting): loads recent messages, saved memories, related past conversations, your user_rules, and live project and task state into the context window. The agent starts each turn already knowing who you are and what you were working on.
• act: the agent does whatever it was asked. It now has your history in scope, so tool calls, plans, and responses reflect your real situation.
• save_turn (after acting): persists the exchange to your Vilix account. Future turns, in this agent or any other, can retrieve it via semantic or keyword search.

This pattern is what powers cross-AI memory: the same store that a Cursor session writes to is the one a Claude Code session reads from, and the one your autonomous agent acts on.

Connecting the endpoint

The Vilix MCP server is available at a single SSE endpoint:

https://api.vilix.ai/mcp

To wire it into any harness that supports custom MCP connectors, use the JSON snippet below. Most frameworks (including Manus, OpenClaw, Hermes, and any harness that reads an mcpServers config) accept this format directly:

{
  "mcpServers": {
    "vilix": {
      "url": "https://api.vilix.ai/mcp",
      "transport": "sse"
    }
  }
}

After saving, authenticate when the harness prompts you. No SDK install, no browser extension, no additional wiring needed.

For a full walkthrough of the protocol and available tools, see the MCP integration docs.

When to use projects, tasks, and rules

Vilix memory has three surfaces that agents can read and write:

• Cross-tool memory: a searchable store of past conversations and saved notes. The agent retrieves the most relevant entries automatically viaget_context. Good for anything factual: decisions made, context established, work completed.
• Projects and tasks: a lightweight project manager whose state auto-injects into context. If your agent is driving a multi-step build, create a project and tasks in Vilix so every run picks up exactly where the last one left off, even across different tools or devices.
• user_rules and project_rules: short directives applied to every context load ("short answers", "always use TypeScript", "check open tasks before starting"). Rules fire automatically, so the agent respects your preferences without you repeating them in every prompt.

Together these surfaces mean the agent does not just remember what happened. It also knows what is in progress and how you want things done.

Works across the tools you already use

Vilix supports any agent harness or coding tool that accepts a custom MCP connector. The ones most commonly used with persistent agent workflows include ChatGPT, Claude, Claude Code, Cursor, Codex, Grok, GitHub Copilot, Windsurf, Lovable, and purpose-built autonomous agent harnesses. For deep-dives on specific runtimes, see:

• OpenClaw: persistent agent memory with Vilix
• Hermes: agent memory with Vilix
• Always-on agent memory across WhatsApp and Telegram

Each of those posts shows the same core pattern above applied to a specific harness, with screenshots and edge cases for that runtime.

Getting started

The free plan covers the essentials. If you want the full 7-day Pro trial with unlimited memory and project state, try Vilix free and connect your first agent in a few minutes. The MCP docs have copy-paste config for every supported harness.

Frequently asked questions

What is the Vilix MCP endpoint?

The endpoint is https://api.vilix.ai/mcp with SSE transport. You add it as a custom MCP connector in your agent harness, authenticate once, and memory tools are available immediately. There is no SDK to install and no browser extension.

Does my agent need custom code to call get_context and save_turn?

No. MCP-compatible runtimes discover and call Vilix tools automatically once the connector is registered. You configure the endpoint, not the call logic. The harness handles when to call each tool based on its built-in MCP orchestration.

What gets loaded by get_context on each agent turn?

get_context returns recent messages from your history, semantically related past conversations, any memories you or a previous agent explicitly saved, your active user_rules, and the current state of any Vilix projects and tasks. All of it arrives in context before the agent starts reasoning.

Can multiple agents share the same Vilix memory?

Yes. Memory is tied to your Vilix account, not to a specific tool or session. An OpenClaw run, a Hermes run, and a Claude Code session all read from and write to the same store, so work done by one agent is immediately visible to the others.

Which agent harnesses does Vilix support?

Any harness that accepts a custom MCP connector with SSE transport. This includes ChatGPT, Claude, Claude Code, Cursor, Codex, Grok, Manus, GitHub Copilot, Windsurf, Lovable, OpenClaw, Hermes, and any custom agent runtime that supports the MCP spec.