Telemetry: AI agents

One-command install, the MCP server and agent skills that give your coding agent production evidence.

Give your coding agent the same services, traces, logs, incidents and deploys you see in the dashboard.

One-command install

Sets up the MCP server and the agent skills in Claude Code, Muse Code, Cursor, Antigravity, Codex CLI, OpenCode and Gemini CLI. Run it in a terminal on macOS or Linux (Windows: WSL); from a project folder if you want a project install.

curl -fsSL https://telemetry.tasktrooper.ai/install-agent.sh | bash
  1. Finds the coding tools installed on this machine and asks which ones to set up.
  2. Asks whether to install globally (every project) or only for the current project.
  3. Asks for an API key (Settings → API keys), checks it against the API and saves it in a file only you can read: ~/.config/tasktrooper/mcp.env, or .tasktrooper/mcp.env in the project (added to .gitignore). Tool configs never contain the key.
  4. Asks whether agents may create alert rules, SLOs and load tests after your approval (off by default).
  5. Downloads tt-mcp for your OS and checks its checksum, copies the trooper-* skills, and registers the server in each tool.

Without questions (CI, dotfiles):

TT_API_KEY=<api-key> bash -c "$(curl -fsSL https://telemetry.tasktrooper.ai/install-agent.sh)" -- \
  --yes --tools claude,cursor --scope global --read-only

Run it again to add a tool, change the key or turn writes on or off. Manual setup per tool is below.

MCP server

tt-mcp is a Model Context Protocol server for coding agents. It runs locally over stdio, wraps the TaskTrooper API and is scoped to one project by its API key. It only reads unless you turn writes on.

Manual: binary and key file:

git clone https://github.com/makifbaysal/tasktrooper-telemetry && cd tasktrooper-telemetry/services/mcp
GOWORK=off go build -o ~/.local/bin/tt-mcp ./cmd/tt-mcp

# settings: environment variables, or this file (mode 600)
mkdir -p ~/.config/tasktrooper && umask 077 && cat > ~/.config/tasktrooper/mcp.env <<'EOF'
TT_API_URL=https://telemetry-api.tasktrooper.ai
TT_API_KEY=<api-key>
TT_MCP_ALLOW_WRITE=false
EOF

Claude Code:

claude mcp add --scope user tasktrooper -- ~/.local/bin/tt-mcp

Cursor (/.cursor/mcp.json) · Antigravity (/.gemini/config/mcp_config.json):

{
  "mcpServers": {
    "tasktrooper": { "type": "stdio", "command": "/Users/<you>/.local/bin/tt-mcp", "args": [] }
  }
}

OpenCode (~/.config/opencode/opencode.json):

{
  "mcp": {
    "tasktrooper": { "type": "local", "command": ["/Users/<you>/.local/bin/tt-mcp"], "enabled": true }
  }
}

Codex CLI:

codex mcp add tasktrooper -- ~/.local/bin/tt-mcp

Muse Code (~/.config/muse/settings.json):

{
  "schema_version": 1,
  "mcp_servers": {
    "tasktrooper": { "transport": "stdio", "command": "/Users/<you>/.local/bin/tt-mcp", "args": [], "mode": "optional", "enabled": true }
  }
}
  • Read-only by default. With TT_MCP_ALLOW_WRITE=true an agent can also create alert rules, SLOs and load tests, but every change is shown as a dry run first and is only written after you approve it. Everything it creates is labelled “Agent” in the dashboard.
  • The API key decides the organisation and project. Create one under Settings → API keys. tt-mcp reads it from the environment or from the first env file it finds: $TT_MCP_ENV_FILE, .tasktrooper/mcp.env in the project, then ~/.config/tasktrooper/mcp.env. Optional TT_ORG_ID and TT_PROJECT_ID are checked at startup.
  • The key only travels in the Authorization header. It never appears in tool output, errors or logs.
  • Log messages and span attributes are masked before they reach the agent: e-mail addresses, IPs, bearer tokens, TaskTrooper keys and card-like numbers.
  • Results are capped at 64 KB. A trimmed result says so and suggests how to narrow the query.

Tools

Tools that read a time span accept range (15m to 7d, default 1h) and an optional env.

  • tt_list_services: Services with throughput, error rate and latency. Start here.
  • tt_get_service_kpis: Health, RED metrics, dependencies and versions of one service.
  • tt_list_endpoints: Routes and consumers of a service, with ids for root-cause analysis.
  • tt_endpoint_rca: Why one endpoint got slower or errorier, per dependency against a baseline.
  • tt_search_traces: Recent traces by service, endpoint, duration or error.
  • tt_get_trace: Full span tree of one trace.
  • tt_search_logs: Log lines by text, level, service, route or trace id, paginated.
  • tt_list_errors · tt_get_error: Error groups by fingerprint, and one with its latest stack.
  • tt_list_incidents · tt_get_incident: Open and recent incidents; one with root cause and timeline.
  • tt_list_monitors · tt_list_kpis: Alert rules and SLOs with their state, burn rate and budget.
  • tt_preview_monitor: Replays an unsaved alert rule over past data: how often would it have fired? Saves nothing.
  • tt_list_alert_suggestions · tt_list_inventory: Alerts suggested from code analysis, and the routes, crons and consumers found in the repository.
  • tt_list_monitor_templates: Ready-made infrastructure, serverless and LLM alert rules.
  • tt_list_notify_channels: Where alerts can go: Slack channels the bot sees and configured channels, each with its exact target string.
  • tt_get_app_summary · tt_get_ai_overview: Web / mobile app health, and LLM calls, tokens and cost.
  • tt_list_hosts · tt_list_databases · tt_list_consumer_groups: Hosts, databases and queue consumer groups with their health.
  • tt_list_deploys: Deploy markers, to line an incident up with a release.
  • tt_list_loadtest_scenarios · tt_list_loadtest_runs · tt_get_loadtest_run: Load test scenarios, verified target domains and run results.

Write tools

Only with TT_MCP_ALLOW_WRITE=true. Each call first returns what it would send; the agent shows it to you and writes only after you approve.

  • tt_create_monitor · tt_update_monitor · tt_delete_monitor: Alert rules. Deletes only rules an agent created.
  • tt_accept_suggestion: Turns a code-analysis suggestion into an alert rule.
  • tt_create_kpi · tt_update_kpi · tt_delete_kpi: SLOs with fast and slow burn-rate alerts.
  • tt_send_slack_test: Posts a test message to check the bot can reach a channel.
  • tt_create_loadtest_scenario · tt_run_loadtest · tt_stop_loadtest: A baseline load test against a verified domain when there is too little traffic to set thresholds. Stopping needs no confirmation.

Agent skills

Skills tell an agent when to use the tools and in which order. Each is a single SKILL.md.

  • trooper-diagnose: Something is slow, failing or alerting. Walks incidents → KPIs → endpoint root cause → traces → logs → deploys, cites every claim and says “unknown” when the evidence is thin. Needs the MCP server.
  • trooper-alerts: Set up alerting for a project: reads services, traffic, existing rules and channels, derives every threshold from your data (“p95 over the last 5 minutes > 800 ms”), previews how often each would have fired, and creates the approved list. Suggests a short load test when there is too little traffic. Needs the MCP server.
  • trooper-query: A question about production data: slowest endpoints, error logs for a trace, what deployed today. Teaches scoping, pagination and how to read truncated results. Needs the MCP server.

Manual:

# global: Cursor, Codex, OpenCode, Gemini CLI and Muse Code read ~/.agents/skills
cp -r tasktrooper-telemetry/skills/trooper-{diagnose,query,alerts} ~/.agents/skills/
ln -s ~/.agents/skills/trooper-* ~/.claude/skills/          # Claude Code
ln -s ~/.agents/skills/trooper-* ~/.gemini/config/skills/   # Antigravity

# one project: .agents/skills (and .claude/skills for Claude Code)
SDKs
Edit this page on GitHub