# minutes
[](https://github.com/silverstein/minutes)
[](LICENSE)
[](https://crates.io/crates/minutes-cli)
**Open-source conversation memory.** [useminutes.app](https://useminutes.app)
Agents have run logs. Humans have conversations. **minutes** captures the human side — the decisions, the intent, the context that agents need but can't observe — and makes it queryable.
Record a meeting. Capture a voice memo on a walk. Ask Claude *"what did I promise Sarah?"* — and get an answer. Your AI remembers every conversation you've had.
Minutes is not just a meeting-notes app. It is local conversation infrastructure for agents: audio capture, transcripts, decisions, commitments, people, and provenance exposed through plain files, CLI commands, MCP tools, and live transcript streams.
> **Own every conversation you've ever had.** Cloud meeting tools rent your own conversations back to you. Minutes writes every meeting to `~/meetings/` as plain markdown, which every AI you use (Claude Code, Codex, Gemini CLI, Cursor, OpenCode, Pi) reads directly. No SDK. No API key. No vendor to outlive. Ten years from now, `grep` still works on your corpus. [**For agents →**](https://useminutes.app/for-agents) · [**Frontmatter schema →**](docs/architecture/frontmatter-schema.md)
<p align="center">
<img src="docs/assets/demo.gif" alt="minutes demo — record, dictate, phone sync, AI recall" width="750">
</p>
### Works with
<p align="center">
<a href="#claude-code-plugin">Claude Code</a> •
<a href="#any-mcp-client-claude-code-codex-gemini-cli-claude-desktop-or-your-own-agent">Codex</a> •
<a href="#opencode-cli">OpenCode</a> •
<a href="#pi-coding-agent">Pi</a> •
<a href="#any-mcp-client-claude-code-codex-gemini-cli-claude-desktop-or-your-own-agent">Gemini CLI</a> •
<a href="#any-mcp-client-claude-code-codex-gemini-cli-claude-desktop-or-your-own-agent">Claude Desktop</a> •
<a href="#mistral-vibe">Mistral Vibe</a> •
<a href="#vault-sync-obsidian--logseq">Obsidian</a> •
<a href="#vault-sync-obsidian--logseq">Logseq</a> •
<a href="#phone--desktop-voice-memo-pipeline">Phone Voice Memos</a> •
Any MCP client
</p>
## Quick start
```bash
# macOS — Desktop app (menu bar, recording UI, AI assistant)
brew install --cask silverstein/tap/minutes
# macOS — CLI only
brew tap silverstein/tap && brew install minutes
# Newer Homebrew versions distrust third-party taps by default; if brew warns
# "Skipping silverstein/tap because it is not trusted", run once:
brew trust silverstein/tap
# Any platform — from source (requires Rust + cmake; Windows also needs LLVM)
cargo install minutes-cli # macOS/Linux
cargo install minutes-cli --no-default-features # Windows (see install notes below)
# MCP server only — no Rust needed (Claude Code, Codex, OpenCode, Gemini CLI, Claude Desktop, etc.)
npx minutes-mcp
```
```bash
minutes setup --model small # Download whisper model (466MB, recommended)
minutes record # Start recording
minutes stop # Stop and transcribe
```
## Docs and agent surfaces
The README is now the product overview and install guide, not the only home for agent-facing reference.
- Agent entry point: <https://useminutes.app/for-agents>
- MCP tools reference: <https://useminutes.app/docs/mcp/tools>
- MCP tools markdown mirror: <https://useminutes.app/docs/mcp/tools.md>
- Error reference: <https://useminutes.app/docs/errors>
- Concise agent index: <https://useminutes.app/llms.txt>
- Full agent index: <https://useminutes.app/llms-full.txt>
## Choose your surface
- `Desktop app` — `brew install --cask silverstein/tap/minutes`
Best for first recording, live capture, Recall, and post-meeting artifact work.
- `MCP server` — `npx minutes-mcp`
Best for agent-first search, recall, and meeting-memory workflows in Claude Desktop, Codex, OpenCode, Gemini CLI, and other MCP clients.
- `CLI` — `brew tap silverstein/tap && brew install minutes`
Best for terminal-first local operator workflows, import, search, and vault sync.
- `Claude Code plugin` — `claude plugin marketplace add silverstein/minutes`
Best for workflow guidance, prep, debrief, and meeting coaching with the lifecycle skills and hooks.
- `OpenCode project integration` — built-in `.opencode/skills/` + `.opencode/commands/`
Best for OpenCode users who want native `/minutes-*` commands plus the portable Minutes skill pack in the repo.
## How it works
```
Audio → Transcribe → Diarize → Summarize → Structured Markdown → Relationship Graph
(local) (local) (LLM) (decisions, (people, commitments,
whisper.cpp pyannote-rs Claude/ action items, topics, scores)
/parakeet (native) Ollama/ people, entities) SQLite index
Mistral/OpenAI
```
Everything runs locally. Your audio never leaves your machine (unless you opt into cloud LLM summarization). Speakers are identified via native diarization. The relationship graph indexes people, commitments, and topics across all meetings for instant queries.
## Features
### Record meetings
```bash
minutes record # Record from mic
minutes record --title "Standup" --context "Sprint 4 blockers" # With context
minutes record --language ur # Force Urdu (ISO 639-1 code)
minutes record --device "AirPods Pro" # Use specific audio device
minutes record --template standup # Apply a summary template
minutes stop # Stop from another terminal
```
**Recording calls (Zoom, Meet, Teams, Webex):** the desktop app captures both your mic and the call's audio natively (ScreenCaptureKit, macOS 15+, no extra software). Grant Screen Recording + Microphone permission and start from the "Call detected" banner; Google Meet and Teams-in-browser need their experimental detection toggles enabled. The CLI (`minutes record`) cannot use native capture, so for command-line call recording you route system audio through BlackHole and a Multi-Output Device. Full setup in [`docs/architecture/audio-devices.md`](docs/architecture/audio-devices.md).
### Consent disclosure aid
For meetings where participant notice is required, Minutes can show a reminder,
require an interactive acknowledgement, and stamp the chosen basis into the
markdown frontmatter. This is a disclosure aid, not advice; ensure everyone
present consents where required.
```bash
minutes record --consent verbal_all_parties
minutes record --consent notice_in_invite --consent-notice "Notice was included in the calendar invite."
```
```toml
[consent]
mode = "remind" # off | remind | require
disclosure_script = "Heads up: I'm using Minutes to transcribe this conversation locally on my device for my own notes. Let me know if you'd prefer I didn't."
# default_basis = "notice_in_invite"
```
When present, artifacts include:
```yaml
consent: verbal_all_parties
consent_notice: Heads up: I'm using Minutes to transcribe this conversation locally on my device for my own notes. Let me know if you'd prefer I didn't.
```
### Sensitive meetings
Use a sensitive meeting when you want timed typed markers and a saved meeting
artifact, but no audio capture.
```bash
minutes sensitive start --title "Board prep"
minutes note "Opened with pricing risk"
minutes sensitive stop
```
The stop flow writes a normal markdown meeting with `capture: none` and
`sensitivity: restricted`. In a terminal, Minutes prompts for a short debrief.
From scripts or other non-interactive callers it saves immediately with
`debrief: pending` so an assistant can help finish the written summary later.
### Take notes during meetings
```bash
minutes note "Alex wants monthly billing not annual billing" # Timestamped, feeds into summary
minutes note "Logan agreed" # LLM weights your notes heavily
```
### Process voice memos
```bash
minutes process ~/Downloads/voice-memo.m4a # Any audio format
minutes process ~/.minutes/native-captures/2026-05-19-120148-call.voice.wav --type meeting
minutes watch # Auto-process new files in inbox
```
### Search everything
```bash
minutes search "pricing" # Full-text search
minutes search "onboarding" -t memo # Filter by type
minutes actions # Open action items across all meetings
minutes actions --assignee sarah # Filter by person
minutes list # Recent recordings
```
### Relationship intelligence
> *"What did I promise Sarah?"* — the query nobody else can answer.
```bash
minutes people # Who you talk to, how often, about what
minutes people --rebuild # Rebuild the relationship index
minutes people merge junrei junlei jun-rei # Confirm variants are one person (canonical first)
minutes commitments # All open + overdue commitments
minutes commitments --person alex # What did I promise Alex?
```
Tracks people, commitments, topics, and relationship health across every meeting. Detects when you're losing touch with someone. Suggests duplicate contacts ("Sarah Chen" ↔ "Sarah") and name-variant fragments a transcriber spelled several ways ("junrei" ↔ "junlei" ↔ "jun-rei"). `minutes people --rebuild` prints a ready-to-run `minutes people merge` command under each suggested cluster; confirming it records a durable alias so every variant collapses to the canonical person on future rebuilds. Powered by a SQLite index rebuilt from your markdown in <50ms.
### Cross-meeting intelligence
```bash
minutes research "pricing strategy" # Search across all meetings
minutes person "Alex" # Build a profile from meeting history
minutes consistency # Flag contradicting decisions + stale commitments
```
### Live transcript (real-time coaching)
```bash
minutes live # Start real-time transcription
minutes stop # Stop live session
```
Streams local transcription to a JSONL file in real time — any AI agent can read it mid-meeting for live coaching. Depending on your build and config, live mode can run on Whisper, Parakeet, or the experimental Apple Speech standalone-live path. Apple Speech currently applies to standalone live transcript (`minutes live`) and opt-in dictation finalization, not recording-sidecar or batch transcription, and it falls back to a ready Parakeet backend before Whisper if Apple Speech is unavailable or fails mid-session in live mode. See [docs/architecture/apple-speech.md](docs/architecture/apple-speech.md) for the current Apple Speech scope. The MCP `read_live_transcript` tool provides delta reads (by line cursor or wall-clock duration). Works with Claude Code, Codex, OpenCode, Gemini CLI, or any agent that reads files. The Tauri desktop app has a Live Mode toggle that starts this with one click.
### Dictation mode
```bash
minutes dictate # Speak → text appears as you talk
minutes dictate --stdout # Output to stdout instead of clipboard
```
Text streams progressively as you speak (partial results every 2 seconds). By default it accumulates across pauses and writes the combined text to clipboard + daily note when dictation ends. Set `[dictation] accumulate = false` to keep the older per-pause behavior. The default backend is local Whisper; on supported macOS builds, `[dictation] backend = "apple-speech"` tries Apple DictationTranscriber for final utterances, and `[dictation] backend = "parakeet"` tries the installed Parakeet backend for final utterances. Both opt-in paths keep Whisper partials and fallback. Linux clipboard output works through `wl-clipboard` on Wayland or `xclip` / `xsel` on X11; desktop auto-paste only attempts X11 paste automation when `xdotool` is available. Local engines, no cloud.
### Command palette (desktop app)
Press `⌘⇧K` from anywhere on macOS to open a keyboard-first palette of every Minutes command. Start a recording, drop a note into the active session, jump to the latest meeting, search transcripts, or rename the meeting open in your assistant — all without leaving the keyboard. Backed by a single typed command registry in `minutes-core`, so visibility follows real backend state: stop-recording only appears while you're recording, mid-recording dictation rows are hidden, and the list re-fetches automatically when state changes.
Recents float to the top with their original payload intact (re-running a `Search transcripts: pricing` from history skips the retype). The shortcut defaults on for both fresh installs and upgrades, with a one-time macOS notification on first launch announcing the binding. Disable it from the Settings overlay (Command Palette section) or by setting `[palette] shortcut_enabled = false` in your config file (`$XDG_CONFIG_HOME/minutes/config.toml` when `XDG_CONFIG_HOME` is set, otherwise `~/.config/minutes/config.toml`). The Settings dropdown also offers `⌘⇧O` and `⌘⇧U` if `⌘⇧K` collides with your IDE.
### Templates (RFC 0001, Phase 1)
```bash
minutes template list # Bundled + project + user templates
minutes template show standup # Inspect a template
minutes record --template standup # Apply when recording
minutes process voice-memo.m4a --template voice-memo
```
Templates layer prompt-level guidance on top of the baseline structured extraction (`KEY POINTS`, `DECISIONS`, `ACTION ITEMS`, `OPEN QUESTIONS`, `COMMITMENTS`, `PARTICIPANTS`). Phase 1 ships four bundled templates (`meeting`, `standup`, `1-on-1`, `voice-memo`) and resolves overrides from `.minutes/templates/` (project) and `~/.minutes/templates/` (user). Custom `extract:` schemas, policy rules, and clinical templates land in later phases — see [`docs/rfcs/0001-templates.md`](docs/rfcs/0001-templates.md).
### Try it without a mic
```bash
minutes demo --full # Seed 5 sample meetings (Snow Crash theme)
minutes demo --query # Cross-meeting intelligence demo
minutes demo --clean # Remove sample meetings
```
The interactive demo seeds interconnected meetings, then lets you pick a thread to explore. Two storylines, five meetings, zero setup.
### System diagnostics
```bash
minutes health # Check model, mic, calendar, disk
minutes demo # Run a pipeline test (bundled audio, no mic)
```
## Switching from Granola?
Import your meeting history into Minutes' conversation memory. Once imported, your meetings become searchable context for AI agents, feed the relationship graph for meeting prep, and surface action items and decision patterns across months of conversations.
```bash
minutes import granola --dry-run # Preview what will be imported
minutes import granola # Import all meetings to ~/meetings/
```
Reads from `~/.granola-archivist/output/`. Meetings are converted to Minutes' markdown format with YAML frontmatter. Duplicates are skipped automatically. All your data stays local — no cloud, no $18/mo.
> **Populating the export directory:** `~/.granola-archivist/output/` has to be filled by a separate Granola export tool first. Recent Granola versions encrypt their local cache, which can break exporters that scrape it. If `minutes import granola` finds nothing, use the API-based [granola-to-minutes](https://github.com/calvindotsg/granola-to-minutes) route below instead (it reads Granola's API and writes straight to `~/meetings/`).
### Want transcripts and AI summaries?
[granola-to-minutes](https://github.com/calvindotsg/granola-to-minutes) exports richer data using [granola-cli](https://github.com/magarcia/granola-cli), a community-built CLI tool (not affiliated with Granola Labs) that accesses Granola's internal API:
| | `minutes import granola` | `granola-to-minutes` |
|---|---|---|
| **Data source** | Local export (`~/.granola-archivist/output/`) | Granola internal API via [granola-cli](https://github.com/magarcia/granola-cli) |
| **Notes & transcript** | ✓ | ✓ |
| **AI-enhanced summaries** | — | ✓ |
| **Action items & decisions** | — | ✓ (extracted via Claude) |
| **Speaker attribution** | — | ✓ (`speaker_map` in frontmatter) |
| **Setup** | Export from Granola desktop app | `npm install -g granola-to-minutes` |
| **Works on free tier** | ✓ | ✓ |
| **API stability** | N/A (local files) | Internal API — may change without notice |
```bash
npx granola-to-minutes export # Export to ~/meetings/
```
## Output format
Meetings save as markdown with structured YAML frontmatter:
```yaml
---
title: Q2 Pricing Discussion with Alex
type: meeting
date: 2026-03-17T14:00:00
duration: 42m
context: "Discuss Q2 pricing, follow up on annual billing decision"
action_items:
- assignee: mat
task: Send pricing doc
due: Friday
status: open
- assignee: sarah
task: Review competitor grid
due: March 21
status: open
decisions:
- text: Run pricing experiment at monthly billing with 10 advisors
topic: pricing experiment
---
## Summary
- Alex proposed lowering API launch timeline from annual billing to monthly billing/mo
- Compromise: run experiment with 10 advisors at monthly billing
## Transcript
[SPEAKER_0 0:00] So let's talk about the pricing...
[SPEAKER_1 4:20] I think monthly billing makes more sense...
```
Works with [Obsidian](https://obsidian.md), grep, or any markdown tool. Action items and decisions are queryable via the CLI and MCP tools.
## Phone → desktop voice memo pipeline
No phone app needed. Record a thought on your phone, and it becomes searchable memory on your desktop. Claude even surfaces recent memos proactively — "you had a voice memo about pricing yesterday."
The watcher is folder-agnostic — it processes any audio file that lands in a watched folder. Pick the sync method that matches your setup:
| Phone | Desktop | Sync method |
|-------|---------|-------------|
| **iPhone** | **Mac** | iCloud Drive (built-in, ~5-30s) |
| **iPhone** | **Windows/Linux** | iCloud for Windows, or Dropbox/Google Drive |
| **Android** | **Any** | Dropbox, Google Drive, Syncthing, or any folder sync |
| **Any** | **Any** | AirDrop, USB, email — drop the file in the watched folder |
### Setup (one-time)
**Step 1: Create a sync folder** — pick one that syncs between your phone and desktop:
```bash
# macOS + iPhone (iCloud Drive)
mkdir -p ~/Library/Mobile\ Documents/com~apple~CloudDocs/minutes-inbox
# Any platform (Dropbox)
mkdir -p ~/Dropbox/minutes-inbox
# Any platform (Google Drive)
mkdir -p ~/Google\ Drive/minutes-inbox
# Or just use the default inbox (manually drop files into it)
# ~/.minutes/inbox/ ← already exists
```
**Step 2: Add the sync folder to your watch config** in your config file (`$XDG_CONFIG_HOME/minutes/config.toml` when `XDG_CONFIG_HOME` is set, otherwise `~/.config/minutes/config.toml`):
```toml
[watch]
paths = [
"~/.minutes/inbox",
# Add your sync folder here — uncomment one:
# "~/Library/Mobile Documents/com~apple~CloudDocs/minutes-inbox", # iCloud
# "~/Dropbox/minutes-inbox", # Dropbox
# "~/Google Drive/minutes-inbox", # Google Drive
]
```
**Step 3: Set up your phone**
<details>
<summary><strong>iPhone (Apple Shortcuts)</strong></summary>
1. Open the **Shortcuts** app on your iPhone
2. Tap **+** → Add Action → search **"Save File"**
3. Set destination to `iCloud Drive/minutes-inbox/` (or your Dropbox/Google Drive folder)
4. Turn OFF "Ask Where to Save"
5. Tap the **(i)** info button → enable **Share Sheet** → set to accept **Audio**
6. Name it **"Save to Minutes"**
Now: Voice Memos → Share → **Save to Minutes** → done.
</details>
<details>
<summary><strong>Android</strong></summary>
Use any voice recorder app + your cloud sync of choice:
- **Dropbox**: Record with any app → Share → Save to Dropbox → `minutes-inbox/`
- **Google Drive**: Record → Share → Save to Drive → `minutes-inbox/`
- **Syncthing** (no cloud): Set up a Syncthing share between phone and desktop pointing at your watched folder. Fully local, no cloud.
- **Tasker/Automate** (power users): Auto-move new recordings from your recorder app to the sync folder.
</details>
<details>
<summary><strong>Manual (any phone)</strong></summary>
No sync setup needed — just get the audio file to your desktop's watched folder:
- **AirDrop** (Apple): Share → AirDrop to Mac → move to `~/.minutes/inbox/`
- **Email**: Email the recording to yourself → save attachment to watched folder
- **USB**: Transfer directly
</details>
**Step 4: Start the watcher** (or install as a background service):
```bash
minutes watch # Run in foreground
minutes service install # Install all background services (macOS launchd / Linux systemd)
minutes service status # Check what's running
minutes service restart # Restart all services (e.g. after upgrading the binary)
```
`minutes service install` sets up three agents:
| Agent | Schedule | What it does |
|-------|----------|--------------|
| **watcher** | Always on | Processes voice memos from `~/.minutes/inbox/` |
| **weekly-summary** | Sundays 7pm | Generates a weekly digest to `~/.minutes/automations/` |
| **proactive-context** | Daily 8am | Builds a context bundle (recent meetings, stale commitments, losing-touch alerts) |
> **Upgrading?** `minutes service install` is idempotent. Re-running it after a binary
> upgrade rewrites all plists/units and reloads with the new binary path.
### How it works
```
Phone (any) Desktop (any)
─────────── ─────────────
Record voice memo → Cloud sync / manual transfer
Share to sync folder │
▼
minutes watch detects file
│
probe duration (<2 min?)
├── yes → memo pipeline (fast, no diarization)
└── no → meeting pipeline (full)
│
transcribe → save markdown
│
├── event: VoiceMemoProcessed
├── daily note backlink
└── surfaces in next Claude session
```
Short voice memos (<2 minutes) automatically route through the fast memo pipeline — no diarization, no heavy summarization. Long recordings get the full meeting treatment. The threshold is configurable: `dictation_threshold_secs = 120` in `[watch]`.
### Optional: sidecar metadata
If your phone workflow also saves a `.json` file alongside the audio (same name, `.json` extension), Minutes reads it for enriched metadata:
```json
{"device": "iPhone", "source": "voice-memos", "captured_at": "2026-03-24T08:41:00-07:00"}
```
This adds `device` and `captured_at` to the meeting's frontmatter. Works with any automation tool (Apple Shortcuts, Tasker, etc.).
Supports `.m4a`, `.mp3`, `.wav`, `.ogg`, `.webm`. Format conversion is automatic — uses [ffmpeg](https://ffmpeg.org/) when available (recommended for non-English audio), falls back to [symphonia](https://github.com/pdeljanov/Symphonia).
If a desktop call capture leaves a raw file under `~/.minutes/native-captures/`, process that audio file directly with `minutes process <path> --type meeting`. For compatibility, `minutes import <audio-file>` also routes to the same meeting-processing path; `minutes import granola` remains the Granola history importer.
### Vault sync (Obsidian / Logseq)
```bash
minutes vault setup # Auto-detect vaults, configure sync
minutes vault status # Check health
minutes vault sync # Copy existing meetings to vault
```
Three strategies: **symlink** (zero-copy), **copy** (works with iCloud/Obsidian Sync), **direct** (write to vault). `minutes vault setup` detects your vault and recommends the right strategy automatically.
## Claude integration
minutes is a native extension for the Claude ecosystem. **No API keys needed** — Claude summarizes your meetings when you ask, using your existing Claude subscription.
```
You: "Summarize my last meeting"
Claude: [calls get_meeting] → reads transcript → summarizes in conversation
You: "What did Alex say about pricing?"
Claude: [calls search_meetings] → finds matches → synthesizes answer
You: "Any open action items for me?"
Claude: [calls list_meetings] → scans frontmatter → reports open items
```
### Any MCP client (Claude Code, Codex, OpenCode, Gemini CLI, Claude Desktop, or your own agent)
Minutes exposes a standard MCP server. Point any MCP-compatible client at it:
```json
{
"mcpServers": {
"minutes": {
"command": "npx",
"args": ["minutes-mcp"]
}
}
}
```
Canonical MCP reference now lives at:
- <https://useminutes.app/docs/mcp/tools>
- <https://useminutes.app/docs/mcp/tools.md>
- <https://useminutes.app/llms.txt>
The MCP surface currently includes recording control, meeting search/retrieval, relationship memory, structured insights, live transcript reading, dictation, QMD integration, and an interactive dashboard resource. Tool names, resource URIs, and prompt templates are generated from the live product surface instead of hand-maintained in this README.
**Interactive dashboard (Claude Desktop):** tools render an inline interactive UI via [MCP Apps](https://modelcontextprotocol.io/specification/2025-03-26/server/utilities/apps) — meeting list with filter/search, detail view with fullscreen + "Send to Claude" context injection, People tab with relationship cards and click-through profiles, and consistency reports. Text-only clients see the same data as plain text.
### OpenCode CLI
Minutes now ships a project-local OpenCode integration layer:
- `.opencode/skills/minutes-*` for OpenCode's one-level skill discovery
- `.opencode/commands/minutes-*.md` so you can run native slash commands like `/minutes-brief`
- the same portable runtime helpers used by the Codex/Gemini skill pack
OpenCode also reads this repo's `AGENTS.md`, so the project rules carry over automatically.
For MCP tools in OpenCode, the official CLI flow is:
```bash
opencode mcp add
```
Choose a local stdio server and point it at:
```bash
npx minutes-mcp
```
If you're wiring OpenCode against this repo before the next npm release is cut,
point it at the repo-local entrypoint instead:
```bash
npm --prefix /absolute/path/to/minutes/crates/mcp exec tsx src/index.ts
```
For the native skill/command workflow, just launch OpenCode in this repo:
```bash
opencode
```
Then use commands like:
```text
/minutes-brief
/minutes-prep Alex
/minutes-debrief
/minutes-weekly
/minutes-video-review /absolute/path/to/demo.mp4
```
### Pi coding agent
Minutes works with Mario Zechner's `pi` coding agent in two places:
- `engine = "agent"` can call `pi` directly for local meeting summarization.
- The desktop Recall panel can launch Pi when `[assistant].agent = "pi"`.
- Pi auto-discovers this repo's existing `.agents/skills/minutes/` skill pack, so there is no separate `.pi/skills` tree to keep in sync.
Install Pi, log in or configure a provider, then set:
```toml
[summarization]
engine = "agent"
agent_command = "pi"
```
Minutes invokes Pi in non-interactive, no-tools mode with a private prompt file. Configure provider/model defaults in Pi itself; Minutes does not currently forward extra `[summarization]` CLI flags. That keeps summarization opt-in and prevents the agent from writing to the repo while it is turning a transcript into notes.
For the interactive Recall panel, Minutes launches Pi directly and passes `[assistant].agent_args` through. Pi still owns provider auth and model selection: use Pi's `/login` and `/model` flows first. If a GitHub Copilot model reports that personal access tokens are unsupported, refresh the Pi Copilot login instead of adding a GitHub PAT to Minutes.
This is separate from Inflection's Pi chatbot/model. Inflection's Pi models are optimized for warmth and emotional intelligence, but the Inflection API terms say not to send regulated personal data. Meeting transcripts often contain personal data, so Minutes does not route transcripts to Inflection by default.
### Mistral Vibe
Add Minutes to your `~/.vibe/config.toml`:
```toml
[[mcp_servers]]
name = "minutes"
transport = "stdio"
command = "npx"
args = ["minutes-mcp"]
```
All 31 tools are available in Vibe as `minutes_*` (e.g. `minutes_start_recording`, `minutes_search_meetings`).
### Claude Code (Plugin)
Install the plugin from the marketplace:
```bash
# First-time install
claude plugin marketplace add silverstein/minutes
claude plugin install minutes
# Restart Claude Code to load skills, hooks, and the meeting-analyst agent
```
**Upgrading?** `claude plugin marketplace add` is a no-op when the marketplace is already on disk — it won't fetch new versions. To pick up new skills and hooks after a release, refresh the marketplace mirror first, then update the plugin:
```bash
claude plugin marketplace update minutes # git pulls the local marketplace mirror
claude plugin update minutes@minutes # installs the new version into the cache
# Restart Claude Code to apply
```
19 skills, 1 agent, 2 hooks:
```
├── Capture: /minutes-record, note, list, recap, cleanup, verify, setup
├── Search: /minutes-search
├── Lifecycle: /minutes-brief, prep, debrief, weekly
├── Coaching: /minutes-tag, mirror
├── Knowledge: /minutes-ideas, lint, ingest
├── Intelligence: /minutes-graph
├── Artifacts: /minutes-video-review
├── Agent: meeting-analyst (cross-meeting intelligence)
└── Hooks: SessionStart meeting briefings + PostToolUse recording alerts
```
**Meeting lifecycle skills** — inspired by [gstack](https://github.com/garrytan/gstack)'s interactive skill pattern:
```
/minutes-brief → fast one-pager (or fired automatically by hook 15 min before calls)
↓
/minutes-prep "call
