Burrow is an independent open-source project built on the same mo engine as mole.fit (the official Mole for Mac app by mo's author), but it is not affiliated with or endorsed by mole.fit — its own name, mark, palette, and copy are original.

If you want it and to fund mo's development — buy mole.fit ($9).

A free, open-source, native macOS GUI for the Mole CLI (mo) — clean, uninstall, optimize, analyze disk, and watch live status. Plus long-range history and an MCP server for AI agents.

Burrow wraps the free, open-source mo CLI in a native Mac app: clean junk, purge dev artifacts, sweep leftover installers, uninstall apps, run safe maintenance, map your disk, and watch live system status — all in one translucent window. On top of that it adds things the CLI doesn't have: a long-running history of your Mac's metrics in a local SQLite database, an MCP server so any AI agent (Claude Code, Cursor, Codex…) can ask "what's been happening on this Mac.", and a lot more planned features to come!

brew install --cask caezium/tap/burrow

• Screenshots
• The tools
• How Burrow compares to other tools
• Settings
• Permissions & Full Disk Access
• Requirements
• Install
• Security & trust
• Use it with your AI agent
• Develop & test
• Architecture
• Attribution & license

Explain with AI — point an MCP-capable agent (Claude Code, or a local model via LM Studio) at Burrow and ask your Mac in plain language.

Every scan offers a no-risk preview (--dry-run) first, a clear reclaimed-space summary when it finishes, and a Stop button to abort a running job.

A live, glanceable read of your Mac's vitals, refreshed continuously:

• CPU — usage, load averages (1/5/15), core count, temperature
• Memory — used %, pressure (normal/warning/critical), swap
• GPU — name and utilisation (Apple Silicon via IOAccelerator)
• Disk — capacity and live read/write I/O rates
• Network — up/down throughput per interface
• Battery — percentage, health, cycle count, time remaining
• Health score — Mole's overall 0–100 rating, with a one-line reason
• Top processes — by CPU or memory, sortable and pinnable

• History — long-range charts (5 m → 90 d) over a local SQLite history of every metric, plus peak-per-process tables. Nothing the CLI keeps.
• Activity — a running log of what Burrow has done (cleans, optimizes, scans) and the live status of anything in flight.
• Menu-bar HUD — health hero, metric tiles, top processes, and live job status, all from the menu bar (you can also run as a Dock app instead).
• MCP server — a stdio JSON-RPC server (burrow mcp / Burrow --mcp) plus an optional localhost HTTP API, so any AI agent can query your Mac's recent state. See Use it with your AI agent.

A factual feature/scope comparison. mole.fit is from the original author of mo — buy it ($9) if you want that and to fund mo.

Everything is local and takes effect immediately unless noted:

Cleaning system and app caches means reading TCC-protected folders, so macOS will prompt — once per folder — unless the app has Full Disk Access. Burrow handles this honestly:

• Before a flood-prone scan it shows a gate explaining the trade-off, with a one-click link to System Settings → Full Disk Access (grant once, no more prompts).
• Don't want to grant it? Scan with admin runs the same scan as root — root bypasses TCC, so it's a single password prompt instead of a flood.
• Burrow only ever reads sizes; it never opens that data itself, and the real cleanup always goes through macOS's own admin dialog.

• macOS 14+
• The Mole CLI — brew install mole. Hard requirement; Burrow refuses to launch without mo on PATH (and offers a guided install if it's missing).

Releases are unsigned for now (pre-1.0; notarization is being wired up — see #10). Each path below clears the Gatekeeper quarantine for you. The full security/trust write-up — network, admin rights, and the trade-offs — is in SECURITY.md.

brew install mole                        # required engine
brew install --cask caezium/tap/burrow   # the app (clears quarantine)

Download Burrow-x.y.z.zip from Releases, unzip into /Applications, then:

xattr -cr /Applications/Burrow.app
open /Applications/Burrow.app

brew install xcodegen mole
git clone https://github.com/caezium/Burrow.git && cd Burrow
xcodegen generate
xcodebuild -project Burrow.xcodeproj -scheme Burrow \
  -configuration Release -destination 'generic/platform=macOS' \
  -derivedDataPath build \
  CODE_SIGN_IDENTITY="" CODE_SIGNING_REQUIRED=NO CODE_SIGNING_ALLOWED=NO build
cp -R build/Build/Products/Release/Burrow.app /Applications/
xattr -cr /Applications/Burrow.app
open /Applications/Burrow.app

Burrow lives in the menu bar (it's a menu-bar agent). Click the icon → Open Burrow — or turn the menu-bar icon off in Settings to run it as a Dock app.

Burrow drives the audited mo CLI. The honest privacy picture:

• No accounts, no ads. Your metrics, history, and file contents stay on your Mac. Burrow does send opt-out, anonymous usage analytics and crash reports (no files, paths, metrics, or stored IP — sizes/counts are bucketed); turn it off in Settings. Full list in TELEMETRY.md.
• No background root helper. When Clean/Optimize need admin rights, macOS's own dialog asks you and Burrow runs that one mo command, then exits — you approve every elevation.
• Local-only surfaces: the MCP HTTP server is loopback-only (127.0.0.1, on by default — toggle it off in Settings) and history is a local SQLite file. The Updates tab runs brew outdated, the same check brew does for itself.
• Unsigned, pre-1.0 — full honest write-up, including the trade-offs of the admin path and the "Scan with admin" option, in SECURITY.md.

Burrow doubles as an MCP server over stdio, so any MCP-capable agent — Claude Code, Cursor, Codex, Cline, Zed, and others — can read your Mac's recent state. Same server, same {command, args} shape everywhere.

Paste this to your coding agent and it'll wire itself in:

Add the Burrow MCP server to my config so you can read my Mac's system history. It's a local stdio MCP server — run it as burrow mcp if the Homebrew shim is on my PATH, otherwise /Applications/Burrow.app/Contents/MacOS/Burrow with args ["--mcp"]. Add it under my MCP servers, reload, and confirm the tools burrow_snapshot, burrow_history, burrow_top_processes, burrow_process_usage, and burrow_info are available. Then tell me my Mac's current CPU and memory.

The config is the same JSON for every agent — only the file differs:

{
  "mcpServers": {
    "burrow": {
      "command": "/Applications/Burrow.app/Contents/MacOS/Burrow",
      "args": ["--mcp"]
    }
  }
}

If you installed via Homebrew, a burrow shim is on your PATH, so you can use command: "burrow", args: ["mcp"] instead of the bundle path. Reload the agent and ask in plain language.

Tools:

• burrow_snapshot — the latest full status snapshot
• burrow_history — a time-series slice of recent snapshots
• burrow_top_processes — top processes by peak CPU over a window
• burrow_process_usage — rank processes by cpu_time / peak_cpu / avg_cpu / peak_mem, with the window it used echoed back
• burrow_info — what Burrow is recording, retention, and freshness

There's also an optional localhost HTTP API (127.0.0.1:9277 — /health, /info, /snapshot, /metrics) for dashboards or curl.

xcodegen generate
xcodebuild -project Burrow.xcodeproj -scheme Burrow \
  -configuration Debug -destination 'platform=macOS' test

The suite covers the parts that matter through public interfaces: DB roundtrip

• range + stride sampler + prune + corruption recovery, Store clamping/defaults, Maintenance prune, MCP tool routing + the semantic usage ranking, squarified treemap invariants, the Full Disk Access decision, and mo output parsing.

mo status --json   ──>  Sampler ──> SQLite (WAL) ──┬─> Status / History (charts)
                                                   ├─> HTTP QueryServer (:9277)
                                                   └─> burrow mcp (stdio) ─> Claude Code / Cursor / Codex
mo analyze --json  ──>  DiskScanner + squarified Treemap ──────> Analyze
mo clean / purge / installer / optimize ─> CommandRunner (streamed) ─> the tool tabs
mo uninstall --list ─>  Software (+ brew outdated for Updates)

One binary, two modes: default is the menu-bar GUI; burrow mcp (or Burrow --mcp) is the stdio MCP server (it forks before SwiftUI claims the process). The whole UI is one translucent window with a top-pill nav (Brand/Tool design system); Settings, History, and Activity are panes in that same window.

MIT.

• Mole CLI (mo) is © tw93, MIT. Burrow depends on it at runtime and bundles nothing from it.
• Inspired by the mole.fit Mac app (same author as mo). Burrow is an independent reimplementation with its own brand — no assets, icons, copy, or trade dress are taken from mole.fit.
• The history-DB + MCP pattern shares lineage with the same author's Stats fork (caezium/stats@henry/history-mcp).
• Treemap layout: Bruls, Huijsen & van Wijk (2000), "Squarified Treemaps," re-implemented from scratch in Swift.

Continuous Updates & Windows Support: Burrow is in active development! We will continuously roll out new updates, features, and improvements. We are also actively working on bringing Burrow to Windows in the near future!

Become a Contributor: Burrow is a community-driven project, and we would absolutely love your help to shape its future. Whether it's fixing bugs, building new features, improving documentation, or helping with the upcoming Windows version, everyone is warmly welcome to join us. Feel free to open issues, submit pull requests, or share your ideas. We look forward to having you as a contributor!