Burnout-Radar

Zero-knowledge burnout detection for healthier, happier teams.

Comment

BurnoutRadar

Inspiration

Managers need to protect their teams from burnout, but traditional monitoring tools are invasive ("creepyware") and destroy trust, while quarterly surveys are too slow. We wanted an ethical alternative: an agent that detects systemic team stress using pure mathematics and aggregate communication metadata — with no need to ever read private messages.

What it does

BurnoutRadar is a privacy-first Slack agent that spots early signs of team burnout and delivers actionable insights to managers. It analyzes anonymized metadata to detect three risk profiles:

  • Key Person Dependency — one contributor carries the team's communication load.
  • Systemic Crunch Time — the team is overwhelmed by inbound requests but lacks capacity to respond.
  • Silent Isolation — public communication drops and shifts entirely to private DMs. When an anomaly triggers, the agent queries Google Gemini 2.5 Flash to translate the raw math into a human-readable summary, then delivers an ephemeral Slack Block Kit dashboard with 1-click resolutions (e.g., an anonymous pulse survey or a "No-Meeting Day" announcement).

How we built it

A distributed system on a strict Zero-Knowledge Architecture (ZKA).

1. The ZKA Backend (Golang) The ingestion pipeline zeroes out PII at the memory level before it escapes the stack frame. Slack User IDs are hashed in RAM using HMAC-SHA256 with an ephemeral salt.

The Go daemon computes statistics over anonymous integer slices — the Gini Coefficient for workload inequality:

$$G = \frac{2 \sum_{i=1}^{n} i x_i}{n \sum_{i=1}^{n} x_i} - \frac{n+1}{n}$$

and rolling Z-scores to detect volume anomalies against baselines:

$$Z = \frac{X - \mu}{\sigma}$$

Only these scalars are written to SQLite, exposed via a custom JSON-RPC 2.0 Model Context Protocol (MCP) server so the zero-knowledge metrics are queryable by external AI agents.

2. The Edge Agent (Deno & TypeScript) A lightweight Deno server handles Slack webhooks. On /burnout, it pulls metrics from the Go MCP daemon, evaluates thresholds, and streams context to Gemini 2.5 Flash to generate the dynamic Block Kit UI.

Challenges we ran into

  • Slack's 3-second rule: Webhooks must be acknowledged within 3 seconds, but querying the daemon and Gemini caused timeouts. Solved by instantly returning 200 OK and processing asynchronously, posting via chat.postEphemeral.
  • Concurrent state management: High-volume webhooks across channels risked race conditions. Solved with a two-tier locking strategy (sync.RWMutex for the global registry, sync.Mutex per pipeline) so the evaluation ticker runs flawlessly alongside incoming traffic. ## Accomplishments we're proud of
  • True zero-knowledge: powerful, AI-driven workplace analytics without compromising employee privacy.
  • A custom MCP server built from scratch in Go, bridging a secure local database and LLM reasoning.
  • Balancing a highly concurrent backend with a frictionless frontend experience. ## What we learned
  • The mechanics of the JSON-RPC 2.0 spec for MCP integration.
  • Advanced memory management in Go to enforce data destruction and prevent PII leakage.
  • How to prompt Gemini 2.5 Flash as an analytical engine that turns cold math into actionable empathy. ## What's next for BurnoutRadar
  • Expanded MCP tools for querying historical trends across multiple weeks.
  • Data visualization — Gini distributions and Pareto curves rendered directly in Slack Block Kit.
  • Organization rollups — aggregating anonymized channel scores into an org-wide health dashboard.

Built With

Share this project:

Updates