Caveman Privacy Implications: What Data Never Leaves Your Machine

Caveman operates as a privacy-first, offline-first tool that transmits zero user data after installation, with no telemetry, analytics, crash reporting, or backend connections.

Caveman is a CLI utility designed for AI agent context management that prioritizes user privacy by design. Understanding the caveman privacy implications reveals why it is suitable for security-sensitive environments, enterprise deployments, and air-gapped networks. After the initial one-time installation from public repositories, the application executes exclusively through local file operations without any network dependencies.

What Data Caveman Never Transmits

According to the project's [SECURITY.md](https://github.com/JuliusBrussee/caveman/blob/main/SECURITY.md), Caveman explicitly guarantees that user-generated data remains confined to the local machine. The repository states: "Caveman no phone home. No telemetry, no analytics, no accounts, no backend."

User Session Logs and Terminal Data

The /caveman-stats command reads your local Claude Code session logs to calculate token savings, but never uploads these logs. In src/hooks/caveman-stats.js, the implementation uses only Node.js fs operations to parse ~/.claude/session.log:

// src/hooks/caveman-stats.js (simplified)
import fs from 'fs';
import path from 'path';

const logPath = path.join(process.env.HOME, '.claude', 'session.log');
const log = fs.readFileSync(logPath, 'utf8');
const stats = computeSavings(log); // pure local computation
console.log(`Saved $${stats.usd} (${stats.tokens} tokens)`);

All file I/O is synchronous and local; no fetch, http, or https modules are invoked.

Skill Configurations and Rule Files

All AI agent skills, system prompts, and compression rules reside in your local agent configuration directory. These files are read from and written to local disk only, with no external API calls to cloud storage or remote configuration servers.

Compressed File Backups

When using /caveman-compress, the tool creates *.original.md backup copies in the same directory as the source file. As implemented in scripts/compress.js, this operation performs pure text transformation through local file system calls:

// scripts/compress.js
import fs from 'fs';

function compressFile(file) {
  const src = fs.readFileSync(file, 'utf8');
  const compressed = cavemanCompress(src); // local transformation
  const backup = `${file}.original.md`;
  
  fs.copyFileSync(file, backup);
  fs.writeFileSync(file, compressed);
}

The script touches only the specified file and its backup; no network sockets are opened.

Network Activity: Installation vs. Runtime

The caveman privacy implications differ between installation time and runtime execution. The codebase maintains a strict boundary where network access is permitted only during the initial setup.

Zero Network Calls After Installation

Post-installation, Caveman operates as an offline-first tool. The runtime components—including skill prompts, local hooks, and the statistics command—function solely on local files. An audit of the codebase confirms no http, https, or fetch calls exist in any runtime execution paths.

Installation-Time Network Requests

The only permitted network traffic occurs during the one-time installation process:

1. Fetching the installer script from raw.githubusercontent.com
2. Downloading skill packages via npm or agent-specific CLIs (Claude, Gemini, etc.)

These requests target public repositories and are pinned to immutable release tags (e.g., v1.9.1). Each downloaded asset is verified against a SHA-256 manifest before execution.

Cryptographic Verification at Install

Before writing any files to disk, the Caveman installer validates package integrity using cryptographic hashing. The bin/install.js script implements SHA-256 verification to ensure the downloaded payload matches the expected checksum:

// bin/install.js (excerpt)
import crypto from 'crypto';
import https from 'https';

https.get('https://raw.githubusercontent.com/JuliusBrussee/caveman/v1.9.1/hooks.zip', (res) => {
  const data = [];
  res.on('data', chunk => data.push(chunk));
  res.on('end', () => {
    const buffer = Buffer.concat(data);
    const sha256 = crypto.createHash('sha256').update(buffer).digest('hex');
    if (sha256 !== EXPECTED_SHA256) {
      throw new Error('Checksum mismatch – aborting install');
    }
    // Extract files locally; no further network traffic
  });
});

This verification ensures that even the initial network fetch cannot inject malicious payloads, and no subsequent network connections are required.

Enterprise and Air-Gapped Deployments

Because the runtime has zero network dependencies, Caveman functions completely offline after a one-time install. In air-gapped environments, you can clone the repository manually and run the installer locally without external internet access. This architecture makes Caveman suitable for classified networks, HIPAA-compliant environments, and proprietary codebases where data exfiltration risks are unacceptable.

Summary

• No telemetry or analytics: Caveman contains no tracking code, phone-home mechanisms, or usage statistics collection.
• No post-install network activity: After initial setup, the tool operates entirely offline with no HTTP requests.
• Local-only data retention: Session logs, skill files, and backups remain in your agent configuration directory.
• Verified installation: All initial downloads are pinned to release tags and checked against SHA-256 hashes.
• Air-gapped compatible: The runtime functions without network access, supporting offline and isolated environments.

Frequently Asked Questions

Does Caveman collect crash reports or usage analytics?

No. According to the source code analysis of SECURITY.md and runtime hook files, there is no telemetry, analytics, crash reporting, or "phone-home" behavior implemented anywhere in the codebase. The tool is explicitly designed to keep all operational data on the local machine.

Can Caveman be used in air-gapped environments?

Yes. Because Caveman requires zero network calls after installation, it works completely offline. You can perform a one-time installation from a local clone of the repository, and all subsequent operations—including /caveman-stats and /caveman-compress—function without internet connectivity.

What happens to my data when I run /caveman-stats?

The command reads your local Claude Code session log from ~/.claude/session.log, performs pure local computation to calculate token savings and cost estimates, and displays results in the terminal. No data is transmitted to external services, logged to remote servers, or stored outside your local file system.

How does Caveman verify installer integrity?

During installation, bin/install.js downloads pinned release assets from GitHub and validates them using SHA-256 cryptographic hashing. Each downloaded blob is checked against an expected hash digest before any files are written to disk, preventing tampered payloads from executing on your system.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}