← Plugin catalog
Developer Tools

Brizz

Brizz v1.0.0

Analytics for your AI agents

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Read
  • Write

Declared limitations

  • Unrelated request (weather). Brizz tools should not be called; the model answers without the plugin or says it cannot help.
  • General coding question with no Brizz data involved. Brizz tools should not be called; the model answers on its own.
  • Request for another company's data. Every token is scoped to the one workspace chosen at sign-in, so no other tenant's data can be returned; the model explains it can only see the connected workspace.

Not specified in the available declarations: pricing & account requirements.

Onboarding example

What are the top open issues in my agent this week?

View onboarding source →

Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 17, 2026. Package observed Nov 16, 2026.

View package source →

Description

From the marketplace listing

Brizz is the product analytics layer for AI agents. It captures every conversation your deployed agents have with their users, evaluates response quality, detects failure patterns, and groups them into issues. Connect your Brizz workspace to ask about your agents in plain language: - Find and read user sessions and their transcripts, errors and tool calls. - Investigate a detected issue: what went wrong, how often, which users it hit, and the evidence behind it. - Query usage, quality, latency and cost metrics, broken down by service, organization, model or cohort. - Manage your workspace: update an issue's status or assignee, link the pull request that fixes it, and edit classifications, cohorts and dashboards. Requires a Brizz account. You choose which workspace to connect when you sign in, and every request is limited to that workspace's data.

Language: English · Automatically detected from descriptions.

Matches for “errors”

Exact text from the indicated source. A mention alone does not establish support for your task.

Publisher full description

Brizz is the product analytics layer for AI agents. It captures every conversation your deployed agents have with their users, evaluates response quality, detects failure patterns, and groups them into issues. Connect your Brizz workspace to ask about your agents in plain language: - Find and read user sessions and their transcripts, errors and tool calls. - Investigate a detected issue: what went wrong, how often, which users it hit, and the evidence behind it. - Query usage, quality, latency and cost metrics, broken down by service, organization, model or cohort. - Manage your workspace: update an issue's status or assignee, link the pull request that fixes it, and edit classifications, cohorts and dashboards. Requires a Brizz account. You choose which workspace to connect when you sign in, and every request is limited to that workspace's data.

Changes

No changes recorded yet. Follow this plugin to keep track of future changes.

First seen Nov 16, 2026. Last seen Nov 17, 2026.

Keywords

Files & skills

File archives

Plugin package8 files · 25.7 KBBrowse files →
Skill instructions
brizz-instrument7.66 KB

View saved version →

---
name: brizz-instrument
description: Add Brizz telemetry to an AI application, or fix an app that is sending nothing or sending it wrong. Trigger when the user asks to install or set up the Brizz SDK, instrument an agent or LLM app, send their first session, wire a framework (LangChain, Vercel AI, Vercel eve, Agno, Strands, LiveKit, MCP servers, Google GenAI, Claude Code, Langfuse), attach users/organizations/events/feedback to sessions, or when a Brizz service shows no sessions, no user identity, or missing tool spans and the cause is upstream in their own code.
---

# Instrument an app with Brizz

Everything else in Brizz assumes spans are arriving. This skill covers the step before that:
getting a codebase to emit them, and fixing it when what arrives is incomplete.

Work against the **published docs** — they are public markdown, version-matched to what
ships, and the same source the dashboard's own setup flow reads from:

```
https://platform.brizz.dev/llms.txt              # index of every page, ~14 KB
https://platform.brizz.dev/docs/<slug>.md        # one page, as markdown
https://platform.brizz.dev/llms-full.txt         # all 142 pages inlined, ~460 KB
```

Fetch `llms.txt`, then open the page for the user's actual stack. Two fetches, a few
thousand tokens. This skill carries only what is stable across stacks and the mistakes that
cost the most time.

Reach for `llms-full.txt` only when you need to search across the whole corpus at once — an
error string whose page you can't guess, or a term you want every mention of. It is the
entire documentation set in one file, so read it from disk with a grep rather than pulling
half a million characters into context.

## Establish three things before writing code

1. **Runtime** — Python 3.10+ or Node 18+. Decides the package *and* the failure mode below.
2. **Framework** — plain provider clients, or LangChain, Vercel AI, Vercel eve, Agno,
   Strands, LiveKit, an MCP server, Google GenAI, or an existing Langfuse tracer. Each has
   its own page under `docs/sdks/`, and in Node several need explicit wiring that nothing
   warns you about. Guessing here is how an install ends up silent.
3. **Credential** — a workspace issues either a **Server DSN** or an **API key**, not both.
   Ask which they were given; don't assume.

Then find where AI calls actually happen — client construction and the request/response
boundary. That boundary is what a session wraps.

## Credential

**Prefer the Server DSN when the workspace issues one.** It is a single string carrying the
credential, the ingestion endpoint, and the service name:

```
https://<credential>@<ingest-host>/<service-name>
```

```bash
export BRIZZ_DSN="https://<credential>@<ingest-host>/<service-name>"
```

```python
Brizz.initialize(dsn=os.environ["BRIZZ_DSN"])          # Python
```
```typescript
Brizz.initialize({ dsn: process.env.BRIZZ_DSN });      // Node
```

There is no `app_name` with a DSN — the service name is already in the string. That is the
whole difference; sessions, users, and events are identical afterwards.

With an API key instead, set `BRIZZ_API_KEY` and pass the service name yourself as
`app_name` / `appName`. Get it right on the first run: it is the name the service is known
by in every later query, and changing it splits the history in two.

A DSN contains a credential. Treat it like a password — environment variable only, never
committed, never shipped to a browser.

## Install and initialize

```bash
pip install brizz        # Python 3.10+
npm install @brizz/sdk   # Node 18+
```

**Python — initialization order is load-bearing.** Auto-instrumentation hooks libraries at
import time, so `Brizz.initialize()` must run *before* you import them:

```python
import os
from brizz import Brizz

Brizz.initialize(dsn=os.environ["BRIZZ_DSN"])

from openai import OpenAI          # after, always
```

**Node — the module list is load-bearing instead.** Hand Brizz the libraries explicitly and
import order stops mattering:

Preview of the first 4,000 characters. Read full instructions →

brizz-investigate8.66 KB

View saved version →

---
name: brizz-investigate
description: Use the Brizz CLI (`brizz`) to investigate production issues, failed sessions, and analytics for AI agents and LLM apps. Trigger whenever the user asks to investigate failures, debug a production AI agent, summarize what's broken today, look at user complaints, find sessions/issues/evidence, query analytics metrics, or mentions Brizz, brizz-cli, or brz. Also trigger on phrases like "what failed", "what's wrong with the agent", "investigate this user", "show me issues", "summarize last 24h", "top failing sessions", or any request to drill into LLM workload telemetry.
---

# Investigate with the Brizz CLI

`brizz` is a read-only, tenant-scoped analytics CLI over the Brizz product analytics platform. It is designed agent-first: deterministic output, stable exit codes, and a `next-commands` convention that lets you self-navigate from one invocation to the next without memorising command names. Reach for it whenever the user wants to investigate failures, look at issues/sessions/evidence, or pull metrics from a Brizz-instrumented LLM workload.

All commands are read-only — there are no mutations. Run them in loops without fear.

## Before you start

Confirm auth and active scope first. These two calls are cheap and prevent a half-hour of debugging the wrong tenant:

```bash
brizz auth whoami --json     # exit 0 = good, exit 2 = not logged in
brizz describe --json        # shows active tenant + app + platform URL
```

If `whoami` exits with code 2, tell the user: `brizz auth login` (OAuth) or `brizz auth login --api-key <key>` (CI / headless). Do not try to fix auth yourself — the CLI handles it interactively.

If the user mentions a tenant or app you do not see in `describe`, override per-call with `--tenant <slug>` / `--app <name>` rather than persisting a switch.

## The canonical investigation workflow

When the user says "investigate", "what's failing", "what's broken today", or anything in that family, follow this 4-step flow. Every step is one command. Every step's output points at the next.

```bash
# 1. Orient — 24h overview: priority counts, top issues, top sessions, metric trends
brizz summarize --output markdown

# 2. Find the issue — ranked by priority + last-seen
brizz --agent issues list --limit 5

# 3. Investigate one — bundles issue + impacted sessions + evidence + conversation tails
brizz issues investigate <issue-id> --output markdown

# 4. Drill into a session — full conversation, compacted to save tokens
brizz sessions conversation <session-id> --compact --limit 200 --output markdown
```

Step 3 is the heavy hitter — it returns issue metadata, top sessions, evidence rows, conversation snippets from each impacted session, and a "Smoking gun" section with the primary evidence's full trace. For most "why is this broken?" questions, you can stop after step 3.

## Always pass `--agent` (or `--output markdown`)

Without a flag, `brizz` autodetects TTY vs pipe and picks a format. In an agent context that detection is unreliable, so be explicit:

- `--agent` is a convenience switch: forces markdown output, disables the pager, and adds `next-commands` trailers to list commands. It's the fastest way to get LLM-readable output.
- `--output markdown` does the markdown part without the rest. Equivalent for read-only single-shot commands.
- `--output json` / `--json` when you need to programmatically parse fields (e.g., extracting an issue ID to feed into the next command). Markdown is for *reading*; JSON is for *parsing*.

Why this matters: markdown output ends with a fenced block like:

```
next-commands
brizz issues investigate abc123-def456 --output markdown
brizz sessions conversation 0xy-bee --limit 200 --output markdown
```

These are copy-paste-ready. Extract the block, pick the relevant line, run it. This is how the CLI guides you through follow-ups without you having to know what to ask for next.

## Token-efficient flags for agent loops

Conversations and evidence can be lon

Preview of the first 4,000 characters. Read full instructions →

brizz-setup4.31 KB

View saved version →

---
name: brizz-setup
description: Get from zero to a working Brizz connection — install the `brizz` CLI, authenticate, confirm the MCP server is reachable, and pick the right access path for the task. Trigger when the user installs or first opens the Brizz plugin, when `brizz` is missing from PATH, when a Brizz command exits with an auth error, when the user asks how to log in, switch tenant, or connect their AI client to Brizz, or when a Brizz question can't be answered because nothing is connected yet.
---

# Set up Brizz access

This plugin gives you two independent ways into a Brizz workspace. They are not
alternatives to choose between once — each answers a different kind of question, and a
normal session uses both.

| Path | Needs | Best at |
|---|---|---|
| **MCP server** (`brizz_*` tools) | OAuth in the client, nothing installed | Structured queries, issue and session lookups, the server's own investigation runbooks |
| **`brizz` CLI** | A binary on PATH plus `brizz auth login` | Terminal work, piping and scripting, `--agent` output you can chain, anything you want to run in a loop |

The MCP server ships with this plugin and needs no install, so **prefer it when you only
need to read something**. Reach for the CLI when the user is working in a terminal, wants
to script a sweep, or asks for it by name.

## Confirm what you already have

Run these before concluding anything is missing. Both are cheap.

```bash
brizz auth whoami --json     # exit 0 = authenticated, exit 2 = not logged in
brizz describe --json        # active tenant, app, and platform URL
```

For the MCP path, call `brizz_whoami` instead — it returns the identity behind the current
token. If that tool isn't available at all, the plugin's MCP server hasn't connected yet;
tell the user to connect Brizz from their client's apps or connectors settings and sign in. Don't try to fix an MCP connection from
the shell.

## Install the CLI

Only needed for the CLI path.

```bash
brew install brizzai/tap/brizz-cli                                          # macOS
```

On Linux or Windows, download the archive for your platform from
https://github.com/brizzai/brizz-cli/releases, extract it, and add `brizz` (`brizz.exe` on Windows) to PATH.

Never build from source to work around a failed install, and never hand-roll API calls
against the platform because the binary is missing — say what failed and let the user
choose.

## Authenticate

```bash
brizz auth login                    # opens a browser for OAuth
brizz auth login --api-key <key>    # CI or headless
```

Auth is interactive and the CLI owns it. If `whoami` exits 2, surface the command and stop
— do not retry, and do not attempt to log in on the user's behalf.

## Set the working scope

Brizz is tenant-scoped, and a query against the wrong tenant looks exactly like a query
that found nothing. Resolution order is **flag > env > config**:

| Context | Flag | Env var | Config field |
|---|---|---|---|
| Tenant | `--tenant` | `BRIZZ_TENANT` | `default_tenant` |
| App | `--app` | `BRIZZ_APP` | `default_app` |

The "app" is the OTel `service.name` of the instrumented application. When the user's
question names one — "checkout assistant is broken" — pass `--app checkout-assistant`
explicitly even if a default is set.

## Verify the whole path end to end

One command proves auth, scope, and that telemetry is actually arriving:

```bash
brizz sessions list --limit 5 --output markdown
```

| What you see | What it means |
|---|---|
| Rows | Everything works. Move on to the task. |
| Empty list, exit 0 | Connected, but this tenant/app has no sessions in the window. Widen `--from`, or check the app is instrumented. |
| Exit 2 | Not authenticated. `brizz auth login`. |
| Exit 3 | The tenant or app slug doesn't exist in this workspace. Re-check `brizz describe`. |

An empty list is the common one, and it is almost never a bug in the CLI. If the app has
never sent telemetry, setup isn't finished — use the **brizz-instrumen

Preview of the first 4,000 characters. Read full instructions →

Release notes

Initial release: search sessions and transcripts, investigate detected issues, query agent metrics, and manage issues, classifications, cohorts and dashboards in your Brizz workspace.

Declared in the saved package. Remote tools may change independently.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package author
Brizz
Keywords
See keywords
Getting started skill
./skills/brizz-setup/SKILL.md
Review scenarios
5 positive · 3 negativeScenario counts, not test results.

Declared capabilities

  • Read
  • Write

Package observed Nov 16, 2026.

Technical details
First seen
Nov 16, 2026 · 18:00 UTC
Last seen
Nov 17, 2026 · 06:00 UTC
Collection status
Collected

plugin_asdk_app_6af767a176dc8191b1ac69088ad7d196

Download plugin data (JSON)

Plugin details: served from cache. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.