Skip to content
/
Tier B A19 Token-efficient encoding

Pare

pare-mcp · Dave-London/Pare · ★ 122 · last commit 2026-05-26

Primitive shape 240 total
MCP tools 240
00

Summary

Pare — Summary

A monorepo of 28 MCP servers providing structured, schema-validated JSON output for 240 developer tools (git, npm, Docker, test runners, cargo, kubectl, and more). The core premise: raw CLI output is fragile and token-expensive for AI agents; Pare returns typed JSON with consistent field names, reducing token consumption by 36–95% per command while eliminating ANSI escape codes, locale-specific formatting, and platform differences.

Each Pare server wraps one category of developer tools (e.g., @paretools/git wraps git and gh, @paretools/test wraps vitest/pytest/jest) and returns MCP structuredContent alongside human-readable content. This uses MCP's output schema feature for type-safe, validated data. The full suite covers version control, languages/packages (npm, pip, cargo, go, deno, bun, nix, dotnet, ruby, swift, jvm), build/lint/test, infrastructure (docker, k8s, terraform), and utilities.

With 122 stars and active development through May 2026, Pare is the most comprehensive structured-output MCP suite in the ecosystem. Setup is via npx @paretools/init --client claude-code --preset web (non-interactive). Compared to seeds: closest to claude-flow (Archetype 3 — MCP server suite) but claude-flow's tools are workflow orchestration while Pare's tools are developer tool wrappers for structured output. Pare is unique in this batch in targeting token efficiency through data normalization rather than through lazy loading or server management.

01

Overview

Pare — Overview

Origin

Created by Dave-London (GitHub), published 2025-2026. Active monorepo with CHANGELOG, full security audit (SECURITY-AUDIT.md), OpenSSF Scorecard badge, and OpenSSF Best Practices badge. Published to npm under the @paretools scope.

Philosophy

"Parsing CLI output is fragile. Raw terminal text includes ANSI escape codes, decorative headers, progress bars, locale-specific formatting, and platform differences that break agent workflows in subtle ways."

"Pare eliminates this entire class of errors by returning schema-validated JSON with consistent field names, regardless of platform, tool version, or locale."

Token Savings Table (from README)

Tool Command Raw Tokens Pare Tokens Reduction
docker build (multi-stage, 11 steps) 373 20 95%
git log --stat (5 commits) 4,992 382 92%
npm install (487 packages) 241 41 83%
vitest run (28 tests) 196 39 80%
cargo build (2 errors) 436 138 68%
pip install (9 packages) 288 101 65%
cargo test (12 tests, 2 failures) 351 190 46%
npm audit (4 vulnerabilities) 287 185 36%

Dual Output Architecture

Each tool call returns TWO outputs:

  • content — human-readable text, for MCP clients that display it
  • structuredContent — typed, schema-validated JSON via MCP's outputSchema feature

Scale

28 npm packages, 240 tools total. Agent gets typed data it can use directly without custom parsing logic.

02

Architecture

Pare — Architecture

Distribution

npm-package — 28 separate npm packages under @paretools/ scope. Installed via npx @paretools/init (setup wizard) or manual npx @paretools/<server>.

Install

# Non-interactive setup with preset
npx @paretools/init --client claude-code --preset web

# Then optionally add agent rules to CLAUDE.md
cat node_modules/@paretools/init/rules/CLAUDE.md >> CLAUDE.md

# Validate
npx @paretools/init doctor

Available Presets

web, python, rust, go, jvm, dotnet, ruby, swift, mobile, devops, full

Package Catalog (28 servers, 240 tools total)

Category Packages Tools Wraps
Version Control git, github 55 git, gh
Languages & Packages npm, python, cargo, go, deno, bun, nix, dotnet, ruby, swift, jvm 101 npm, pip, cargo, go, deno, bun, nix, dotnet, gem, swift, gradle, maven
Build, Lint & Test build, lint, test, cmake, bazel 23 tsc, esbuild, vite, webpack, eslint, prettier, biome, vitest, pytest, jest
Infrastructure docker, k8s, infra, security, remote 40 docker, kubectl, helm, terraform, ansible, trivy, ssh
Utilities search, http, make, process, db 21 ripgrep, fd, curl, make, just, psql, mysql, redis, mongosh

Tool Filtering (via environment variables)

# Per-server filter
PARE_GIT_TOOLS=status,log npx @paretools/git

# Universal filter across all servers
PARE_TOOLS=git:status,git:log,npm:install npx @paretools/git

# Disable all tools from a server
PARE_GIT_TOOLS= npx @paretools/git

Monorepo Structure

Pare/
├── packages/
│   ├── server-git/       # @paretools/git
│   ├── server-npm/       # @paretools/npm
│   ├── server-docker/    # @paretools/docker
│   ├── ... (25 more)
│   ├── init/             # @paretools/init (setup)
│   ├── shared/           # shared TypeScript utilities
│   └── tsconfig/         # shared TypeScript config
├── docs/
│   ├── setup/            # Per-client setup guides (10 clients)
│   ├── tool-schemas/     # JSON response schemas for every tool
│   └── quickstart.md
├── benchmarks/
├── rules/                # CLAUDE.md rules for using Pare tools
├── hooks/                # Leftbook git hooks
└── turbo.json            # Turborepo build orchestration

Supported Clients (setup guides)

Claude Code, Claude Desktop, Cursor, VS Code/Copilot, Windsurf, Cline/Roo Code, OpenAI Codex, Gemini CLI, Zed, Continue.dev

03

Components

Pare — Components

MCP Servers (28) — Complete List

Package Tools Wraps
@paretools/git ~35 git
@paretools/github ~20 gh (GitHub CLI)
@paretools/npm ~12 npm
@paretools/python ~10 pip, python
@paretools/cargo ~10 cargo
@paretools/go ~8 go
@paretools/deno ~7 deno
@paretools/bun ~7 bun
@paretools/nix ~7 nix
@paretools/dotnet ~9 dotnet
@paretools/ruby ~8 gem, bundle, ruby
@paretools/swift ~7 swift, xcodebuild
@paretools/jvm ~8 gradle, maven, java
@paretools/build ~5 tsc, esbuild, vite, webpack
@paretools/lint ~5 eslint, prettier, biome
@paretools/test ~8 vitest, pytest, jest
@paretools/cmake ~5 cmake, ctest
@paretools/bazel ~5 bazel, bazelisk
@paretools/docker ~10 docker, docker-compose
@paretools/k8s ~12 kubectl, helm
@paretools/infra ~8 terraform, ansible
@paretools/security ~5 trivy, snyk
@paretools/remote ~5 ssh, scp
@paretools/search ~5 ripgrep, fd
@paretools/http ~5 curl, wget
@paretools/make ~5 make, just
@paretools/process ~3 ps, kill, top
@paretools/db ~5 psql, mysql, redis, mongosh

Total: 240 tools across 28 servers

@paretools/init Package

Setup utility (not an MCP server):

  • --client <name> flag (claude-code, cursor, vscode, etc.)
  • --preset <name> flag (web, python, rust, etc.)
  • doctor subcommand for validation
  • Non-interactive mode (no prompts)

Rules File

rules/CLAUDE.md — agent rules for using Pare tools effectively. Can be appended to existing CLAUDE.md.

Skills, Hooks, Commands (0)

Pare ships no Claude Code skills, hooks, or slash commands. It is pure MCP servers.

05

Prompts

Pare — Prompts

rules/CLAUDE.md (Agent Instructions)

Pare ships a rules/CLAUDE.md file that provides agent guidance for using Pare tools. This is appended to the project's CLAUDE.md. The exact content is in the npm package (not directly readable from the GitHub root), but it instructs Claude on which Pare tools to prefer over raw shell commands for each category.

Tool Descriptions (in MCP schema)

Each tool has a JSON schema with name, description, inputSchema, and outputSchema. The outputSchema is the key differentiator — it defines the exact structure the agent receives.

Example: git:status tool schema (from docs/tool-schemas/):

The tool returns a strongly-typed JSON object with:

{
  "branch": "string",
  "upstream": "string | null",
  "ahead": "number",
  "behind": "number",
  "staged": [{"file": "string", "status": "modified|added|deleted|renamed|copied"}],
  "modified": ["string"],
  "deleted": ["string"],
  "untracked": ["string"],
  "conflicts": ["string"],
  "clean": "boolean"
}

Prompting Technique Classification

  • Schema-driven structured output: The outputSchema in each tool definition tells the agent exactly what fields to expect
  • Dual output: Both content (human text) and structuredContent (typed JSON) — agent picks the representation it needs
  • ENV-based tool filtering: PARE_GIT_TOOLS=status,log restricts available tools without code changes
  • Preset-based configuration: --preset web configures only the servers relevant to the project type — implicit context narrowing

Agent Integration Guide

The docs/agent-integration.md provides instructions on mapping from raw CLI commands to Pare tools, configuring rules files, and using hooks for automatic tool routing. This is the closest thing to a "skill" in the Pare ecosystem.

09

Uniqueness

Pare — Uniqueness

differs_from_seeds

Closest seed is claude-flow (Archetype 3 — MCP server suite) but claude-flow's 305 tools are workflow orchestration primitives while Pare's 240 tools are developer CLI wrappers for structured output. taskmaster-ai (also Archetype 3) uses a single MCP server for task management. Pare is closest to what the seed rubric calls "cross-tool portability" — with 10 client setup guides, it outperforms all seeds in ecosystem breadth. None of the 11 seeds address structured output normalization as Pare does.

Positioning

Pare occupies a unique niche: it is the most comprehensive "structured CLI output" library for AI agents. The key innovation is using MCP's structuredContent + outputSchema to provide typed data, not just text. This is architecturally distinct from other tool wrappers that return text content only.

Distinctive Opinion

"Parsing CLI output is fragile... Pare eliminates this entire class of errors by returning schema-validated JSON with consistent field names, regardless of platform, tool version, or locale."

The framework argues that the fragility of raw CLI output is a systematic problem that should be fixed at the infrastructure level, not handled with per-agent parsing heuristics.

Observable Failure Modes

  1. Context overhead: 28 servers × N tools = large upfront schema load; ENV filtering helps but requires per-project config
  2. CLI version coupling: Pare's parsers are coupled to specific CLI output formats; breaking changes in underlying tools may break Pare
  3. No streaming: Tool calls are blocking; long builds/tests block the agent session
  4. Ripgrep/fd dependencies: search server requires rg and fd on PATH
  5. No sandboxing: Infrastructure tools (docker, kubectl, terraform, ssh) execute with full user permissions

What Makes It Novel vs. the 11 Seeds

  • Only framework using MCP's structuredContent + outputSchema for typed responses
  • Only framework with 28 MCP servers and 240 tools across the full development toolchain
  • Only framework with 10 client-specific setup guides
  • Highest tool coverage of any framework in the corpus (npm, pip, cargo, go, deno, bun, nix, dotnet, ruby, swift, jvm, gradle, maven, docker, kubectl, terraform, ansible, trivy, ripgrep, psql, mysql, redis, mongosh...)
  • Only framework with formal security audit documentation (SECURITY-AUDIT.md, OpenSSF badges)
04

Workflow

Pare — Workflow

Setup Workflow

# 1. Configure MCP servers with preset
npx @paretools/init --client claude-code --preset web

# 2. Optionally add agent rules
cat node_modules/@paretools/init/rules/CLAUDE.md >> CLAUDE.md

# 3. Restart Claude Code session

# 4. Validate
npx @paretools/init doctor

The web preset configures: @paretools/git, @paretools/github, @paretools/npm, @paretools/build, @paretools/test, @paretools/lint, @paretools/docker, @paretools/http, @paretools/search

Agent Usage Pattern

Once configured, agents use Pare tools instead of raw shell commands:

Agent: "Check git status"
  → pare:git:status()
  → returns JSON: {branch, staged, modified, untracked, ahead, behind}
  → Agent processes typed fields directly (no parsing)

Agent: "Run tests"  
  → pare:test:run()
  → returns JSON: {passed, failed, skipped, duration, failures: [...]}
  → Agent reads failures array directly

Agent: "Build TypeScript"
  → pare:build:tsc()
  → returns JSON: {success, errors: [{file, line, message}], warnings: [...]}
  → Agent processes error objects without regex parsing

Tool Selection via ENV

# Minimal read-only git (no push, commit, add, checkout)
PARE_GIT_TOOLS=status,log,diff,branch,show npx @paretools/git

# Minimal npm
PARE_NPM_TOOLS=install,test,run npx @paretools/npm

Phase/Artifact Table

Phase Artifact
init Updated MCP client config (e.g., ~/.claude.json)
CLAUDE.md update Agent rules appended
tool call content (human text) + structuredContent (JSON)

Approval Gates

None. Tools execute immediately.

git status Example (from README)

Input: git status Pare output:

{
  "branch": "main",
  "upstream": "origin/main",
  "ahead": 2,
  "staged": [
    {"file": "src/index.ts", "status": "modified"},
    {"file": "src/utils.ts", "status": "added"}
  ],
  "modified": ["README.md"],
  "deleted": [],
  "untracked": ["temp.log"],
  "conflicts": [],
  "clean": false
}
06

Memory Context

Pare — Memory & Context

Context Window Impact

Pare has a significant context window footprint. With 28 servers and 240 tools, loading all servers simultaneously would put all 240 tool schemas in context. The --preset system and ENV filtering mitigate this:

  • web preset: ~9 servers, ~90 tools → moderate context usage
  • full preset: 28 servers, 240 tools → high context usage

The token reduction per call is dramatic (36–95%), but the tool schema loading upfront is not addressed by Pare's architecture (unlike mcp-to-skill-converter or mcp2skill which solve this).

No Persistent State

Pare tools are stateless. Each tool call executes a CLI command and returns the result. No database, no memory, no index.

Structured Output Caching

Not mentioned in the README. Each call re-executes the underlying CLI command.

CLAUDE.md Integration

The rules/CLAUDE.md appended to the project persists in the project file (context injected at session start via Claude Code's CLAUDE.md loading).

Cross-Session Behavior

Stateless from Pare's perspective. Session state is whatever the underlying tools track (git history, npm lock file, docker images, etc.).

Context Efficiency vs. Tool Count Tradeoff

Pare represents a deliberate tradeoff: more MCP tools = more schema tokens loaded, but each individual tool call produces dramatically fewer output tokens than its raw CLI equivalent. The breakeven point depends on how many tool calls are made per session.

07

Orchestration

Pare — Orchestration

Multi-Agent Pattern

None. Pare provides tools for agents to use; it doesn't orchestrate agents.

Execution Mode

event-driven — each MCP server runs continuously, responding to tool call requests.

Multi-Model

Not applicable. Model-agnostic MCP servers.

Isolation

None. Tools run in the calling agent's environment, executing CLI commands on the local filesystem.

Dual Output Strategy

The most interesting architectural decision in Pare is the dual output:

// Each tool returns both:
return {
  content: [{type: "text", text: humanReadableSummary}],
  structuredContent: {
    // typed JSON matching outputSchema
  }
}

This uses MCP's structuredContent + outputSchema features — the agent gets typed data it can use programmatically without string parsing.

Concurrency

Each server handles concurrent requests independently. No shared state between servers.

Tool Filtering Architecture

ENV-based filtering (PARE_GIT_TOOLS, PARE_TOOLS) is applied at server startup, not per-request. This means the tool count in tools/list is reduced, directly lowering the context cost of the schema definitions.

Security Model

Documented in SECURITY-AUDIT.md and SECURITY_MODEL.md. Key aspects:

  • Commands run in the calling agent's user context
  • No privilege escalation
  • security server wraps trivy/snyk for vulnerability scanning
  • OpenSSF Scorecard and Best Practices badges indicate security rigor
08

Ui Cli Surface

Pare — UI & CLI Surface

Dedicated CLI Binary

Yes (@paretools/init package)

Attribute Value
Name npx @paretools/init
Language TypeScript (Node.js)
Is thin wrapper No — owns setup logic
Subcommands doctor
Notable flags --client, --preset, non-interactive mode

Local UI / Dashboard

None.

Per-Client Setup Guides

Dedicated setup guides for 10 clients:

Client Guide
Claude Code docs/setup/claude-code.md
Claude Desktop docs/setup/claude-desktop.md
Cursor docs/setup/cursor.md
VS Code / Copilot docs/setup/vscode.md
Windsurf docs/setup/windsurf.md
Cline / Roo Code docs/setup/cline.md
OpenAI Codex docs/setup/codex.md
Gemini CLI docs/setup/gemini-cli.md
Zed docs/setup/zed.md
Continue.dev docs/setup/continue-dev.md

Tool Schemas Documentation

docs/tool-schemas/ — detailed JSON response schemas for every tool. docs/tool-response-examples.md — quick JSON samples.

Cross-Tool Portability

High — the most multi-client framework in this batch. Supports 10 different AI clients out of the box with specific setup guides.

CI/CD

Turborepo-based monorepo build. .changeset for versioning. codecov.yml for coverage. GitHub Actions for CI.

Related frameworks

same archetype · same primary tool · same memory type

Context Mode ★ 16k
A19 Token-efficient encoding

Keeps raw tool output data out of the context window via sandbox execution and SQLite+FTS5 session indexing, reducing context…

lean-ctx ★ 2.2k
A19 Token-efficient encoding

A full-session context runtime that compresses file reads (10 modes), shell output (60+ patterns), and session memory (CCP) to…

Nemp Memory ★ 101
A19 Token-efficient encoding

Persists AI agent context across sessions as 100%-local plain JSON files with zero dependencies, zero cloud, and agent identity…

CogniLayer v4 ★ 28
A19 Token-efficient encoding

Provides AI coding agents with typed semantic memory, tree-sitter code intelligence, and a multi-agent coordination protocol to…

cursor-coding-agent-os (Mugiwara555343) ★ 3
A19 Token-efficient encoding

Lean/Verbose dual-mode Agent OS fork for solo developers on token budgets.

rtk (Real Token Killer) ★ 55k
A19 Token-efficient encoding

Intercepts Claude Code's Bash tool calls at the PreToolUse hook and compresses verbose CLI output (git status, test runners,…