Real isolation. Your keys never leave the box.

Connect hosted memory (Obsidian, gbrain, mem0) to agents from the dashboard, CLI, or MCP — buy a sidecar, then grant it.

What “connected” means

Your agents run in isolated microVMs. Memory is an optional sidecar microVM you buy, then connect (grant) to agents you own. Until you connect it, the agent does not see that memory.

Provider	After you connect
Obsidian, gbrain, mem0	Agent can read/write that memory over MCP

Buy and connect are separate steps:

Buy — provision the sidecar VM (dashboard only today).
Connect — grant that sidecar to a specific agent VM (dashboard, CLI, or MCP).

A connection from the UI shows up in jurniti memory ls. A CLI grant shows up on the Memories page. Same control plane.

Sibling plugins: Observability · Communication.

Bundle a memory companion into a template

When you capture a template, you can declare an optional memory companion recipe (an empty private memory sidecar forked with the agent). This is not a dump of your live memory — only a recipe.

Surface	How
Dashboard	Create template wizard / edit → Composition: memory
CLI	`jurniti capture <vm> --public --memory memoryobsidian`
MCP	`template_capture` with `memory_provider`

On fork, the platform provisions/attaches the companion (comp path free for dogfood; paid tenants complete Memory checkout if needed, then compose-retry). Buying sidecars still happens in the dashboard (no CLI buy).

How to connect memory

A. In the browser (dashboard)

You need at least one agent already running (see Quickstart).

Open Memories

Go to Memories
(app.jurniti.com → left nav Memories, or /dashboard/memories).

Buy a memory (if you do not have one yet)

Under the provider picker, choose Obsidian, gbrain, or mem0, complete Stripe checkout. jurniti provisions a memory microVM (~3 minutes).

When it is ready, it appears under Your memories on the same page. The platform also auto-creates the MCP connection for that memory (you never paste a token).

Connect it to an agent

On the memory’s card, find Connected agents (count like 0/N or 1/N).

Each of your agent VMs is listed as a row. For the agent you want:

Click Connect (or the plug control on that row).
The row switches to connected; the label becomes Disconnect.

That is the grant. Repeat for other agents if you want several wired to the same memory.

To disconnect: click Disconnect on that agent’s row.

Confirm it worked

On the card, Connected agents should show the agent as connected.
Or from a terminal (optional): jurniti memory ls — that agent’s id appears under GRANTED_VMS.

The platform injects MCP config into the agent guest. The agent can use the memory on the next session that loads MCP clients (restart the agent process if it was already mid-session).

What you cannot connect

Only agent VMs appear as connect targets. You cannot connect a memory into another memory or an observability/communication sidecar — the API returns invalid_agent.

B. From the CLI

Prerequisites:

CLI installed and logged in (jurniti login)
A read-write API key (read-only keys can list, not connect)
A memory already bought (step A.2, or any existing connection from jurniti memory ls)

# 1. See connections (ids look like mcpc_…) and which agents already have them
jurniti memory ls

# 2. Find the agent VM id
jurniti vms ls
# pick a row that is an agent (Hermes, Claude Code, …), not the memory VM

# 3. Connect
jurniti memory grant --connection mcpc_YOUR_ID --vm vm-YOUR_AGENT_ID
# → granted connection mcpc_… to agent vm-…

# 4. Confirm
jurniti memory ls
# GRANTED_VMS column should list vm-YOUR_AGENT_ID

# Disconnect later
jurniti memory revoke --connection mcpc_YOUR_ID --vm vm-YOUR_AGENT_ID

Example shape:

jurniti memory ls
# ID                             NAME              PROVIDER         GRANTED_VMS
# mcpc_19ef3c3cc443ea7dea465a68  memory-vm-…       memoryobsidian   -

jurniti memory grant \
  --connection mcpc_19ef3c3cc443ea7dea465a68 \
  --vm vm-68648d6a5722293cc9f7c740
# granted connection mcpc_19ef3c3cc443ea7dea465a68 to agent vm-68648d6a5722293cc9f7c740

Buying the memory VM itself is still done in the dashboard today; the CLI covers list / connect / disconnect.

C. From MCP (your coding agent)

Mount the CLI once so your agent inherits your login — see MCP:

claude mcp add jurniti -- jurniti mcp
# or: codex mcp add jurniti -- jurniti mcp

Then use these tools (same outcomes as the CLI / UI):

Goal	MCP tool	Required args
List memories / connections	`mcp_connections_list`	—
Connect memory → agent	`mcp_connection_grant`	`connection_id`, `vm_id`
Disconnect	`mcp_connection_revoke`	`connection_id`, `vm_id`

Example tool call to connect:

{
  "connection_id": "mcpc_19ef3c3cc443ea7dea465a68",
  "vm_id": "vm-68648d6a5722293cc9f7c740"
}

Discover connection_id with mcp_connections_list (or jurniti memory ls).
Discover vm_id with vms_list (or jurniti vms ls).
Use a read-write key for grant/revoke; list works with read-only.

Your agent operates as you (tenant-scoped). Wrong-role targets fail with the same invalid_agent error as the dashboard.

Quick comparison

Step	Browser	CLI	MCP
Buy memory	Memories page → pick provider → checkout	— (use UI)	—
Connect memory to agent	Memory card → Connected agents → Connect	`jurniti memory grant --connection … --vm …`	`mcp_connection_grant`
Disconnect	Same row → Disconnect	`jurniti memory revoke …`	`mcp_connection_revoke`
List what is connected	Memories page	`jurniti memory ls`	`mcp_connections_list`

After you connect

Control plane stores the grant (tenant-scoped).
Platform injects MCP connection config into the agent guest.
The harness applies its native MCP config when it supports auto-wire (Hermes, Claude Code, Codex, OpenClaw, OpenCode, OpenHands, Goose, DeepAgents, Gemini CLI, …).

You do not SSH in to paste tokens for the platform-managed path.

Which agents auto-wire memory MCP?

Auto-wire (guest config written from the inject file) requires a real MCPClientConfigurer. Agents that have no file-based remote MCP config today are listed with reasons in the test inventory unsupportedMCPClients in internal/harness/mcp_client_configurer_test.go (examples: pi, grok, paperclip, aider, and similar). That list is the single source of truth — we do not stub empty configurers to green a matrix cell. Closing a gap means implementing a real merge script and removing the harness from that map.

CLI demo

Live attach recording (list → grant → list + MCP help):

GIF: jurniti-memory-attach-demo.gif
MP4: jurniti-memory-attach-demo.mp4

Memory