# Observability

> Connect hosted observability sidecars (Latitude, Langfuse) to agents from the dashboard, CLI, or MCP — buy a sidecar, then grant it.

Part of the jurniti developer docs — canonical page: https://www.jurniti.com/docs/observability · full docs index: https://www.jurniti.com/docs/llms.txt

## What “connected” means

Your agents run in isolated microVMs. **Observability** is an optional
**sidecar** microVM you buy, then **connect (grant)** to agents you own. Until
you connect it, the agent does not emit traces into that sidecar.

| Provider | After you connect |
| --- | --- |
| **Latitude**, **Langfuse** | Agent emits traces into that sidecar |

**Buy** and **connect** are separate steps:

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

v1 keeps **one active observability grant per agent**. Same control plane as
[Memory](/docs/memory) and [Communication](/docs/communication).

---

## Bundle an observability companion into a template

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

| Surface | How |
| --- | --- |
| **Dashboard** | Create template wizard / edit → Composition: observability |
| **CLI** | `jurniti capture <vm> --public --observability observabilitylangfuse` |
| **MCP** | `template_capture` with `observability_provider` |

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

---

## How to connect observability

### A. In the browser (dashboard)

You need at least one **agent** already running (see [Quickstart](/docs/quickstart)).

      ### Open Observability

    Go to **[Observability](https://app.jurniti.com/dashboard/observability)**  
    (`app.jurniti.com` → left nav **Observability**, or
    `/dashboard/observability`).

    Sign in with your magic link if you are not already logged in.
        ### Buy a sidecar (if you do not have one yet)

    Choose **Latitude** or **Langfuse**, complete Stripe checkout. jurniti
    provisions an observability microVM (~3 minutes).

    When it is ready, it appears under your sidecars on the same page.
        ### Connect it to an agent

    On the sidecar card, use the grant controls (same idea as Memories’
    **Connect** / **Disconnect**).

    Remember: **one active observability grant per agent** in v1. Connecting a
    second sidecar to the same agent replaces the previous grant.
        ### Confirm it worked

    - On the card, the agent should show as connected.
    - Or from a terminal: `jurniti observability ls` / grant list via MCP.

    The platform injects observability / OTEL config into the agent guest.
  
> **What you cannot connect:** Only **agent** VMs are valid grant targets. You cannot grant an observability sidecar into another sidecar — the API rejects non-agent targets.

---

### B. From the CLI

Prerequisites:

- [CLI installed and logged in](/docs/installation) (`jurniti login`)
- A **read-write** API key (read-only keys can list, not connect)
- An observability sidecar already bought (step A.2)

```bash
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-AGENT
```

Buying the sidecar 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](/docs/mcp):

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

| 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` |

```json
{
  "sidecar_vm_id": "vm-…",
  "agent_vm_id": "vm-…"
}
```

- Discover `sidecar_vm_id` with `jurniti observability ls` or fleet list.
- Discover `agent_vm_id` with `vms_list` (or `jurniti vms ls`).
- Use a **read-write** key for grant/revoke; list works with read-only.

---

## Quick comparison

| Step | Browser | CLI | MCP |
| --- | --- | --- | --- |
| Buy observability | Observability page → checkout | — (use UI) | — |
| **Connect to agent** | Sidecar card → grant to agent | `jurniti observability grant --sidecar … --vm …` | `observability_grant` |
| Disconnect | Same UI → revoke | `jurniti observability revoke …` | `observability_revoke` |
| List grants | Same page | `jurniti observability ls` | `observability_grants_list` |

---

## After you connect

1. Control plane stores the grant (tenant-scoped).
2. Platform **injects** observability / OTEL config into the agent guest.
3. Agent harnesses implement `TelemetryConfigurer` (or use the default apply
   script). Sidecar engines never consume grants as agents.

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

Telemetry is separate from memory MCP auto-wire: memory uses
`MCPClientConfigurer`; observability uses the telemetry path. See also
[Memory](/docs/memory) for the MCP auto-wire inventory note.

## Related

  - [Memory](/docs/memory): Attach Obsidian, gbrain, or mem0 memory engines.
  - [Communication](/docs/communication): Buzz relay for agent messaging (desktop human chat).
  - [Dashboard](/docs/dashboard): Browser path for agents and billing.
  - [CLI reference](/docs/cli-reference): All verbs, including jurniti observability.
  - [MCP](/docs/mcp): Mount jurniti so your agent can grant connects.
  - [Quickstart](/docs/quickstart): Create an agent before you connect a sidecar.