Memory & Observability
How to connect memory and observability to agents in the browser, from the CLI, or via MCP — same grant model on every surface.
What “connected” means
Your agents run in isolated microVMs. Memory and Observability are optional sidecar microVMs you buy, then connect (grant) to agents you own. Until you connect them, the agent does not see that sidecar.
| Sidecar | Providers | After you connect |
|---|---|---|
| Memory | Obsidian, gbrain, mem0 | Agent can read/write that memory over MCP |
| Observability | Latitude, Langfuse | Agent emits traces into that sidecar |
Buy and connect are separate steps:
- Buy — provision the sidecar VM (usually in the dashboard).
- 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.
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).
Sign in with your magic link if you are not already logged in.
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 underGRANTED_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 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_IDExample 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-68648d6a5722293cc9f7c740Buying 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 mcpThen 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_idwithmcp_connections_list(orjurniti memory ls). - Discover
vm_idwithvms_list(orjurniti 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.
How to connect observability
Same pattern as memory: buy sidecar → grant to agent.
Browser
- Open Observability
(/dashboard/observability). - Buy Latitude or Langfuse (checkout → sidecar microVM).
- On the sidecar card, connect agents with the grant controls (same idea as Memories’ Connect / Disconnect).
- v1 keeps one active observability grant per agent.
CLI
jurniti observability ls
# --sidecar = observability VM id; --vm = agent VM id
jurniti observability grant --sidecar vm-SIDE --vm vm-AGENT
jurniti observability revoke --sidecar vm-SIDE --vm vm-AGENTMCP
| Goal | Tool | Args |
|---|---|---|
| List grants | observability_grants_list | — |
| Connect | observability_grant | sidecar_vm_id, agent_vm_id |
| Disconnect | observability_revoke | sidecar_vm_id, agent_vm_id |
{
"sidecar_vm_id": "vm-…",
"agent_vm_id": "vm-…"
}Quick comparison
| Step | Browser | CLI | MCP |
|---|---|---|---|
| Buy memory | Memories page → pick provider → checkout | — (use UI) | — |
| Buy observability | Observability page → checkout | — (use UI) | — |
| Connect memory to agent | Memory card → Connected agents → Connect | jurniti memory grant --connection … --vm … | mcp_connection_grant |
| Disconnect memory | Same row → Disconnect | jurniti memory revoke … | mcp_connection_revoke |
| Connect observability | Observability card → grant to agent | jurniti observability grant --sidecar … --vm … | observability_grant |
| List what is connected | Same pages | jurniti memory ls / observability ls | *_list tools |
After you connect
- Control plane stores the grant (tenant-scoped).
- Platform injects config into the agent guest (memory: MCP connections file; observability: observability / OTEL file).
- The harness applies its native 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?
Buy is dashboard-only for memory and observability SKUs. Connect works
from the dashboard, jurniti memory / jurniti observability, and customer
MCP tools — same grants.
Auto-wire (guest config written from the inject file) requires a real
MCPClientConfigurer (or telemetry configurer for observability). 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.
Telemetry (observability) is separate: agent harnesses implement
TelemetryConfigurer (or use the default apply script); sidecar engines never
consume grants as agents.
CLI demo
Live attach recording (list → grant → list + MCP help):
Related
Swarm — many agents, one command
Fan out dozens of agent microVMs on prepaid Spot credits, dispatch a task to the whole swarm, and collect every result — setup, dispatch, collect.
Agent skills & updates
Install jurniti's agent skills into Claude Code or Codex with jurniti skills install — open SKILL.md format. Keep both current with jurniti upgrade.