One tray app. Every AI coding tool on your machine. Unified OpenTelemetry, flowing to your observability backend; never ours.
Trove auto-detects 17 AI coding harnesses (Claude Code, Antigravity CLI, Codex, Cursor, OpenCode, Cline, Aider, GitHub Copilot CLI, and more), patches each one's telemetry config to emit OTLP, normalizes the cross-vendor signals through a bundled OpenTelemetry Collector, and forwards a unified stream to whichever observability backend you already own: SigNoz, Honeycomb, Datadog, Grafana, New Relic, OpenSearch, Splunk, Elastic, your own self-hosted Collector, or any generic OTLP endpoint.
AI coding tools have a telemetry problem. Every vendor invented their own dialect, every install hides the wiring in a different file, and the data either stays trapped in a proprietary dashboard or gets handed to the vendor as a side effect of you using their CLI. Trove flips that around: point each tool at a local Trove collector once, and from then on every signal your team generates lands in a backend you control, typed consistently, attributed by harness, and auditable end-to-end.
That matters to different people for different reasons.
- One pane of glass across mixed-harness teams. Half the team uses Claude Code, the other half is on Cursor plus Copilot CLI, the platform team trialed Codex last week. Without Trove, that's four separate vendor dashboards (or four blanks). With Trove, every span, metric, and log carries a
harness.idresource attribute so you can compare them side-by-side in one query. - Native OTel where it exists, best-effort where it doesn't. Claude Code, Antigravity CLI, Codex, Qwen, OpenCode, and Cursor ship native OTLP; Trove flips the right flags and routes them through. Cline, Aider, and Copilot CLI don't emit OTel natively, so Trove installs lightweight watchers and shell-rc wrappers that derive equivalent OTLP records from their on-disk logs. The derived records share the same queries as their native peers.
- Reversible. Every "Enable" writes a sentinel-bracketed managed region into the harness's config file. One click reverts it byte-for-byte. No half-applied states, no orphaned env vars, no "I uninstalled Trove but my CLI still POSTs to localhost."
- Detect dead seats before renewal. Your org pays for Cursor, Copilot, Claude Code, and Codex licenses across 200 engineers; Trove tells you which seats actually fire, by user, by week, by tool. The same
harness.id-keyed metric stream that powers the engineering dashboard also surfaces "this license has zero turns in the last 30 days" rows that procurement can act on. - Cross-vendor cost normalization. Token counts, model-call counts, and turn durations all flow through the same Tier-A metric schema (
trove.harness.tokens,trove.harness.events,trove.harness.cost.usd,trove.harness.turn.duration,trove.harness.errors). Cost per turn for Claude Code is directly comparable to cost per turn for Copilot CLI in your own dashboard, with no vendor-specific exporter to maintain. - Your contract, your data residency. Telemetry leaves the machine only toward the backend you configured. Trove never phones home, never aggregates user data, and has no SaaS layer that could change its mind about pricing or data-sharing policies next quarter.
- Localhost-only. The bundled OpenTelemetry Collector listens on
127.0.0.1and forwards exclusively to the endpoint you set. No third-party SDK in the dependency tree phones a vendor. - OS-keychain credential storage. Backend tokens, API keys, and ingest secrets all live in macOS Keychain, Windows Credential Manager, or Linux Secret Service. Never in plaintext JSON, never in env files, never logged.
- Auditable, reversible config patches. Every file Trove touches is wrapped in a sentinel-bracketed managed block; diff it, audit it, revert it. The schema for what got written is captured in
state.jsonand signed off on per-apply. - MIT-licensed, fully open source. Every line of TypeScript, every Rust handler, every adapter is auditable. CI gates ≥ 95% test coverage on the shared schema layer where security-sensitive logic lives.
- ✅ No telemetry. No analytics. No crash reporting. The collector binds to
127.0.0.1and forwards only to the endpoint you configured. - ✅ Credentials in your OS keychain: Keychain on macOS, Credential Manager on Windows, libsecret on Linux. Never in plaintext files, never in logs.
- ✅ Reversible patches. Every "Enable" can be cleanly undone; the original file is restored byte-for-byte.
- ✅ MIT-licensed and fully open source. Every component (Rust core, React UI, custom OTel Collector build, harness adapters) is auditable.
Trove sweeps the standard install paths for every supported AI coding tool the moment it starts, surfaces what's on disk, and lets you enable telemetry per-tool with a single click. Toggle one row and Trove writes a managed region into that tool's config file; the row turns green the moment OTLP starts flowing through the local collector.
Supported today:
| Tier | Harness | Telemetry source |
|---|---|---|
| Native OTel | Claude Code | Built-in OTEL_EXPORTER_OTLP_* env vars |
| Native OTel | Claude Desktop | Auto-detected via local audit log (no setup) |
| Native OTel | Antigravity CLI | Antigravity hooks via ~/.gemini/antigravity-cli/hooks.json |
| Native OTel | OpenAI Codex CLI | Codex 0.130+ [otel.exporter.otlp-http] block |
| Native OTel | OpenAI Codex (desktop) | Shares Codex CLI's codex app-server backend |
| Native OTel | Qwen Code | Built-in OTel exporter |
| Native OTel | OpenCode | Built-in OTel exporter |
| Native OTel | Cursor IDE | Cursor hooks via ~/.cursor/hooks.json |
| Partial coverage | Cursor CLI | Subset of Cursor hook events (shell exec only) |
| Best effort | Cline | Watcher derives OTLP from Cline's task records |
| Best effort | Aider | Shell-rc wrapper tees session log into OTLP |
| Best effort | GitHub Copilot CLI | Shell-rc wrappers around copilot and gh copilot |
| Setup guide | Junie CLI | Setup guide (JetBrains) |
| Setup guide | Droid (factory.ai) | Setup guide |
| Setup guide | Kimi Code CLI | Setup guide |
| Setup guide | Devin | Setup guide |
| Setup guide | ForgeCode | Setup guide |
When a harness is enabled, Trove shows it in the Overview Data flow chart (≤ 3 tools render as individual nodes; 4+ collapse into an animated "Orbital Hub" cluster) with per-source activity halos that light up when telemetry is flowing.
Trove forwards to any backend that speaks OTLP. Thirteen come with pre-built credential forms; two escape hatches (Generic OTLP, Local Collector passthrough) cover everything else.
| Platform | Auth pattern |
|---|---|
| SigNoz Cloud (recommended) | Ingestion key (gRPC or HTTP) |
| Grafana Cloud | Endpoint plus Basic auth |
| Honeycomb | Team API key plus dataset |
| Datadog | DD-API-KEY header plus site selector |
| New Relic | License key plus region (US or EU) |
| Splunk Observability Cloud | Realm plus X-SF-Token access token |
| Dynatrace | Environment URL plus API token |
| Elastic | OTLP/HTTP plus Authorization: ApiKey |
| OpenSearch | OTLP routed to Data Prepper |
| OpenObserve | OTLP plus /api/<organization> path |
| ClickStack (HyperDX) | OTLP plus ingestion key header |
| Chronosphere | Tenant plus API-Token header |
| Sentry | OTLP/HTTP plus X-Sentry-Auth |
| Generic OTLP | Arbitrary endpoint plus any header set |
| Local Collector (passthrough) | OTLP to your own self-hosted collector |
Multi-platform fan-out is the default. Trove broadcasts every signal to every enabled platform; there's no per-platform routing. Configure SigNoz, Honeycomb, and Generic OTLP all at once, and every harness's telemetry lands in all three. Per-platform Disable lets you pause forwarding without losing credentials; re-enable with one click and the collector picks up where it left off.
Each configured platform carries a 4-color health pill (green / amber / red / gray) driven by the collector's own scrape metrics, so you see immediately when an exporter starts dropping traffic. No waiting for the user to notice their dashboard went quiet.
Different harnesses emit telemetry with different attribute shapes, different event names, and different aggregation grains. Trove ships a built-in Tier-A metric schema (trove.harness.events, trove.harness.tokens, trove.harness.cost.usd, trove.harness.turn.duration, trove.harness.errors) and gives you a UI to map any raw harness signal onto it visually, with a live preview.
What you can do from the Mappings tab:
- Synthesis rules. Turn a raw harness counter (e.g.
claude_code.session.count) into a Tier-A metric (trove.harness.events) with optional attribute filters. Rename type to direction, fan a single source into multiple metrics, or alias attribute keys. - Hook rules. For harnesses without native OTel (Cline, Aider, Copilot CLI), tell the watcher how to translate raw events into Tier-A metrics. Same UI surface as synthesis rules.
- Custom metrics. Add your own metric definitions on top of the five built-ins. Custom metrics flow through unchanged (no synthesis required); dashboards on the receiving backend interpret them.
- Live preview. Every rule edit shows the simulated output for a sample event before you apply. Bad rules surface as validation errors at the IPC boundary, not as silent telemetry drops.
- Full-diff view. See exactly what changed before Apply. Reset to defaults wipes your customizations and restores the shipped catalog.
- Apply lives. Mappings are evaluated by the collector itself (
metricstransformplustransform/harness-tagoverlays), so changes take effect on the next reload. No restart, no waiting for an agent to pick up new config.
Grab the latest installer from the Releases page, or pick your platform directly:
| Platform | Format | Download |
|---|---|---|
| macOS, Apple Silicon (M1/M2/M3/M4) | .dmg |
Latest release |
| macOS, Intel | .dmg |
Latest release |
| Windows 10/11 | .msi / NSIS |
Latest release |
| Linux (Debian/Ubuntu) | .deb |
Latest release |
| Linux (Fedora/RHEL) | .rpm |
Latest release |
| Linux (portable) | .AppImage |
Latest release |
macOS note: pre-1.0 builds ship unsigned. The first launch needs a one-time right-click then Open to clear Gatekeeper.
- Install from the Download table above. The OpenTelemetry Collector is bundled inside the app; there is nothing else to install.
- Launch Trove. First-run wizard walks you through picking a backend and entering credentials. The collector starts the moment you Save.
- Open the Harnesses tab. Every supported AI coding tool installed on your machine is already detected. Click Enable on the ones you want to capture.
- Confirm telemetry on the Overview tab. The Data flow chart goes live the moment data flows; the row's telemetry pill turns green within ~5 seconds.
- Open your backend's dashboard. Spans, metrics, and logs land tagged with
harness.id,service.name, and the Tier-A metric set.
That's it. No daemons to babysit, no agents to upgrade, no SaaS account to create.
┌─ Claude Code ──────┐
├─ Antigravity CLI ──┤
AI coding tools ├─ Codex / Cursor ───┤──▶ Trove collector (localhost)
├─ OpenCode / Qwen ──┤ │
└─ Cline / Aider / ──┘ ▼
Copilot CLI / … Tier-A metric synthesis
Cross-harness normalization
Identity overlay (opt-in)
│
▼
┌─────────────────────────────┐
│ Your observability backend │
│ (SigNoz / Honeycomb / │
│ Datadog / Grafana / etc.) │
└─────────────────────────────┘
- Tauri 2 Rust shell with a React plus TypeScript WebView UI. ~30 MB final bundle.
- Custom OpenTelemetry Collector built via
ocband shipped as a sidecar binary, supervised by the Rust core. Restarts on crash, reloads on config change, exits with the app. - OS keychain for backend credentials (via
keyring-rs); secrets never live in JSON state files. - Atomic, sentinel-bracketed config patching so every "Enable" is reversible byte-for-byte.
- State is one JSON file (
state.json); versioned schema, migrated in-place across versions, never reaches outside the user's config directory.
For the full architecture tour see documentation/architecture.md.
- Node.js 24+ and pnpm 10+
- Rust stable (install via rustup)
- Go 1.23+ (needed once to build the OTel Collector sidecar via
ocb) - macOS: Xcode Command Line Tools (
xcode-select --install) - Linux:
libgtk-3-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf - Windows: Visual Studio Build Tools with "Desktop development with C++"
git clone https://github.com/Intevity/trove
cd trove
pnpm installOn a fresh clone, first compile the workspace packages and build + stage the bundled OTel Collector sidecar (the Tauri app spawns the sidecar, so it must exist before the app boots):
pnpm build # compile workspace packages (@trove/shared, …)
pnpm build:collector && pnpm bundle:sidecar # build + stage the OTel Collector sidecarThen launch the dev app:
pnpm --filter @trove/app tauri:devbuild:collector && bundle:sidecar is a one-time step per host (rerun only
when the collector manifest changes); rerun pnpm build whenever a workspace
package's TypeScript changes.
| Command | What it does |
|---|---|
pnpm dev |
Run all package dev scripts in parallel |
pnpm build |
Build every package (TypeScript) |
pnpm build:app |
Build your local changes unsigned and launch them (below) |
pnpm build:app:release |
Full signed tauri build (all targets, needs updater key) |
pnpm build:collector |
Rebuild the bundled OpenTelemetry Collector sidecar |
pnpm bundle:sidecar |
Stage the built collector binary into the app for bundling |
pnpm test |
Run vitest with coverage (≥ 95% gate) |
pnpm typecheck |
Type-check every package |
pnpm lint |
ESLint across the workspace |
pnpm format:check |
Verify Prettier formatting |
pnpm build:apppnpm build:app is the cross-platform dev entrypoint
(scripts/build-app.mjs): it detects the OS, builds without the updater
signing key (no ~/.tauri/*.key prompt, via src-tauri/tauri.dev.conf.json
which sets bundle.createUpdaterArtifacts: false), then launches your
changes. macOS installs to /Applications/Trove.app and opens it; Linux
builds and runs an .AppImage; Windows builds and runs the NSIS
-setup.exe. Preview without building: node scripts/build-app.mjs --dry-run
(add --platform=linux|win32|darwin).
Use pnpm build:app:release for the SIGNED release build (full
tauri build, all targets, signed updater artifacts — prompts for the key
password). CI does this via tauri-action; you rarely need it locally. Do
NOT use build:app:release for the dev loop — it blocks on the key prompt.
Release outputs land in packages/app/src-tauri/target/release/bundle/:
| Platform | Output |
|---|---|
| macOS | macos/Trove.app, .dmg |
| Linux | .deb, .rpm, .AppImage |
| Windows | .msi, NSIS installer |
Pushing a v* tag triggers the release workflow. It builds the Tauri app for every supported platform in parallel, signs and notarizes the macOS bundle, and publishes the draft release once every build is green.
- architecture.md: the full tour of how the Rust core, the React UI, the OTel collector sidecar, and the harness adapters fit together.
- MVP_PLAN.md: the original 17-sprint plan that shipped Trove, with notes on what made it in and what got rolled forward.
- MAPPING_PLAN.md: the Tier-A metric schema, the synthesis-rule grammar, and the mapping overlay's collector-side semantics.
- adding-a-harness.md: the step-by-step guide for contributing a new harness adapter.
- harness-platform-matrix.md: the live results matrix tracking every (harness × platform) pairing we've validated.
- releasing.md: the release runbook (tag, sign, notarize, ship).
- RELEASE_CHECKLIST.md: the human QA gate that runs before every tag.
MIT, see LICENSE. Copyright © 2026 Intevity.
Trove never sends telemetry to a Trove-controlled endpoint. Threat model and vulnerability reporting in SECURITY.md.
See CONTRIBUTING.md for setup, testing conventions, and the harness-adapter contribution guide. Code of Conduct in CODE_OF_CONDUCT.md.