# Dashboard

> Run jurniti from the browser — magic-link login, Add agent, live terminal, templates, plan & billing. No CLI required.

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

## The web path

If you prefer a browser over a terminal, the **dashboard** is the full product.
Same microVMs, same plans, same guarantee — different controls.

Sign in: [app.jurniti.com/login](https://app.jurniti.com/login)

      ### Log in with a magic link

    Enter your email. jurniti sends a one-time link. Click it — you're in. No
    password to invent or reset.

    After login you land on **Agents** (`/dashboard/vms`).
        ### Add an agent

    Click **Add agent**. Two short picks:

    1. **Harness** — the agent runtime (Hermes, OpenClaw, Claude Code, Codex,
       and the rest of the gallery).
    2. **Plan and cycle** — Starter / Pro / Max, monthly or annual.

    Checkout goes through **Stripe**. When payment clears, auto-provision runs
    — roughly **three minutes** to a running microVM. You do not SSH into a
    host; the platform boots the box for you.

    > **No free tier — card required to provision:** There is **no free trial and no free tier**. Bringing up a VM starts a real Firecracker microVM, so Stripe needs a card. The de-risk is the **30-day money-back guarantee** on your first subscription: cancel within 30 days for a full refund.
        ### Open the agent

    From the agents list, open a VM. On the detail page you can:

    - **Browser terminal** — a live PTY in the page. Type into the agent without
      installing anything local.
    - **Harness portal** — the agent's own web UI, when the harness exposes one
      (port and label come from the harness, not a hard-coded product name).
    - **Create template** — snapshot the VM's persist volume into a reusable
      template (private or public).
    - **Start / stop / upgrade / delete** — lifecycle controls for that box.
        ### Plan, credits & templates

    **Plan** (`/dashboard/plan`) is the billing surface:

    - Flat monthly subscriptions — what you're paying per always-on agent.
    - **Prepaid credits** (`/dashboard/plan#credits`) — top up for usage-tier
      (On-Demand / Spot) agents. $10 minimum; card charged only on top-up.
      The first top-up **ends the 30-day money-back guarantee** on your first
      flat subscription (the UI asks you to acknowledge this).
    - **Manage billing** opens the Stripe Customer Portal — update card,
      download invoices, cancel, or switch plan.

    You never type a card number into jurniti's own forms; card fields are
    Stripe's. New On-Demand / Spot agents are launched from the
    [CLI](/docs/usage-tiers) today; the dashboard tops up credits and shows
    those agents once they exist.

    **Templates:**

    | Where | What |
    | --- | --- |
    | **[Gallery](/templates)** | Public templates anyone can browse and fork into a new paid VM |
    | **Your templates** (`/dashboard/templates`) | Templates you own — private slots, public flips, forks |

    Forking starts a **new paid VM** (Stripe Checkout for a flat plan).
    Capturing a private template may require a **Templates plan** if you are
    past any grandfathered free private slots — the UI tells you with a clear
    upgrade gate, not a silent failure.
  
## Other dashboard surfaces

| Page | Use it for |
| --- | --- |
| **Usage** (`/dashboard/token-usage`) | Advisory model-token rollups (BYOK est. — jurniti does not resell tokens). Same data via CLI `jurniti token-usage` and MCP `token_usage` — see [Token usage](/docs/token-usage) |
| **Automations** | Schedule / trigger agent work from the dashboard |
| **Memories** (`/dashboard/memories`) | Buy a memory engine (Obsidian / gbrain / mem0) and **grant** it to agents — see [Memory & Observability](/docs/memory-observability) |
| **Observability** (`/dashboard/observability`) | Buy Latitude / Langfuse sidecars and grant them to agents |
| **Support** | Open and track tickets with the founder-backed support queue |

## Dashboard vs CLI

| Job | Dashboard | CLI |
| --- | --- | --- |
| First agent | **Add agent** wizard | `jurniti up` |
| Card on file | Stripe Checkout / portal | `jurniti billing add-card` (opens browser) |
| Shell into agent | In-browser terminal | Open the VM subdomain / portal |
| List agents | Agents table | `jurniti vms ls` |
| Credits (usage tiers) | Plan → `#credits` top-up | `jurniti credits …` |
| Model token meter | [Token usage](/docs/token-usage) page | `jurniti token-usage` |
| Launch usage-tier VM | (view/manage once running) | `jurniti up --tier …` |
| Swarm of N agents | Prefer CLI today | `jurniti up --count N --group …` |
| Attach memory / observability | Memories / Observability pages | `jurniti memory …` / `jurniti observability …` |
| CI / scripts | — | CLI or MCP |
| Your agent as operator | — | [MCP](/docs/mcp) |

Most day-to-day work works either way. Use the dashboard when you want eyes on
the box; use the CLI when you want a script or a skill.

## Related

  - [Quickstart](/docs/quickstart): Both paths side by side — dashboard and CLI.
  - [Usage tiers](/docs/usage-tiers): Hourly prepaid On-Demand or Spot.
  - [Install the CLI](/docs/installation): When you outgrow the browser or need CI.
  - [Memory & Observability](/docs/memory-observability): Grant memories and trace sidecars from the UI or CLI.
  - [MCP](/docs/mcp): Let your coding agent operate the fleet.