Tamp

Set up Tamp token compression proxy for OpenClaw to reduce Anthropic API input token costs. Use when the user asks to save tokens, reduce API costs, set up t...

Security Scan

The skill's instructions and requirements are consistent with its stated purpose (running a local token-compression proxy for Anthropic requests), but you should audit the npm package/source and treat the proxy process as able to read your API key in transit.

Purpose & Capability

Name and description match the instructions: the SKILL.md only explains installing and configuring a local Tamp proxy and wiring OpenClaw to route requests through it. Nothing requested by the skill (no unrelated credentials, binaries, or config paths) is disproportionate to this purpose.

Instruction Scope

Instructions stay on-purpose (install via npm/npx or from git, run tamp, add a systemd user service, and update OpenClaw provider settings). One important operational detail: the proxy forwards the x-api-key/Authorization header upstream unchanged, so the tamp process will see the API key in requests (in-memory and potentially in logs if configured). The SKILL.md claims Tamp does not store or log keys and is local-only, but those claims are assertions you should verify by inspecting the package source or runtime behavior.

Install Mechanism

No automated install spec in the registry entry (instruction-only). The instructions recommend installing a pinned npm package (@sliday/tamp@0.3.8) or running via npx, and optionally building from git. Using npm/@npmjs registry is expected for this task, but it does fetch code from a third-party package registry—audit or pin the package and consider building from the repository if you need higher assurance.

Credentials

The skill declares no required env vars in metadata, which is consistent with being instruction-only. The README does tell you to ensure your Anthropic API key is present in your OpenClaw config so that OpenClaw forwards it to Tamp. That is proportionate to the purpose, but remember the proxy will observe the header values in transit even if it doesn't persist them—treat the proxy as a component that has access to your API key.

Persistence & Privilege

always:false and no autonomous escalation flags. Persisting Tamp as a systemd user service is a user-chosen deployment step described in the instructions (expected for long-running local proxies). The skill does not request system-wide privileges or modify other skills' configuration beyond telling you to update OpenClaw's provider settings.

Assessment

This skill is coherent with its stated goal of running a local Tamp proxy. Before installing: (1) review and pin the npm package version (or clone and build from the GitHub repo) to ensure there is no unexpected telemetry or exfiltration; (2) remember the proxy will see your Anthropic API key in request headers — run it only on localhost or inside a locked-down container/VM and do not bind it to an external interface; (3) if you run as a service, run under an unprivileged user and inspect logs to ensure keys are not written; (4) consider adding an upstream (direct Anthropic) fallback and monitor requests until you trust the behavior. If you want higher assurance, audit the tamp source code (the skill itself provides the repository link) before using it in production.

Tamp for OpenClaw

Save 3-50% on input tokens by routing API requests through Tamp — a local HTTP proxy that compresses tool_result blocks before they reach Anthropic.

Prerequisites

• Node.js 18+
• Anthropic API key — Tamp proxies requests to Anthropic. Your ANTHROPIC_API_KEY must be set in your OpenClaw config. Tamp itself does not store or read this key — it forwards the x-api-key header from incoming requests unchanged.

1. Install & Run

# Install a pinned version (recommended)
npm i -g @sliday/tamp@0.3.8

# Or run without installing
npx @sliday/tamp@0.3.8 -y

Start with default stages:

TAMP_STAGES=minify,toon,strip-lines,whitespace,dedup,diff,prune tamp -y

Verify:

curl http://localhost:7778/health
# {"status":"ok","version":"0.3.8","stages":["minify","toon",...]}

Tamp is open source (MIT). Audit the source, build from git, or run from a local clone: git clone https://github.com/sliday/tamp && cd tamp && npm install && node bin/tamp.js -y

2. Run as systemd service

Create ~/.config/systemd/user/tamp.service:

[Unit]
Description=Tamp token compression proxy
After=network.target

[Service]
# Adjust path: node -e "console.log(require('child_process').execFileSync('which', ['tamp']).toString().trim())"
ExecStart=/usr/local/bin/tamp
Restart=always
RestartSec=5
Environment=TAMP_PORT=7778
Environment=TAMP_STAGES=minify,toon,strip-lines,whitespace,dedup,diff,prune
Environment=TAMP_LOG=true

[Install]
WantedBy=default.target

systemctl --user daemon-reload
systemctl --user enable --now tamp.service
journalctl --user -u tamp -f  # live compression logs

3. Configure OpenClaw

Add a provider in your OpenClaw config:

{
  models: {
    providers: {
      "anthropic-tamp": {
        baseUrl: "http://localhost:7778",
        apiKey: "${ANTHROPIC_API_KEY}",  // Forwarded to upstream, not stored by Tamp
        api: "anthropic-messages",
        models: [
          { id: "claude-opus-4-6", name: "Claude Opus 4.6 (compressed)" },
          { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (compressed)" }
        ]
      }
    }
  }
}

Set as primary model:

{
  agents: {
    defaults: {
      model: { primary: "anthropic-tamp/claude-opus-4-6" }
    }
  }
}

Restart the gateway. All requests now flow through Tamp.

How it works

OpenClaw → POST /v1/messages → Tamp (localhost:7778) → compresses JSON body → Anthropic API
                                                     ← streams response back unchanged

Tamp intercepts the request body, finds tool_result blocks in messages[], and compresses their content. Headers (including x-api-key) are forwarded unchanged. The response streams back untouched.

7 Compression Stages

Stage	What it does	Lossy?
minify	Strip JSON whitespace	No
toon	Columnar encoding for arrays (file listings, deps, routes)	No
strip-lines	Remove line-number prefixes from Read tool output	No
whitespace	Collapse blank lines, trim trailing spaces	No
dedup	Deduplicate identical tool_results across turns	No
diff	Delta-encode similar re-reads as unified diffs	No
prune	Strip lockfile hashes, registry URLs, npm metadata	Metadata only*

* Prune removes fields like integrity, resolved, shasum, _id, _from, _nodeVersion from JSON — npm registry metadata not needed by the LLM. To keep full provenance, remove prune from TAMP_STAGES.

What to expect

Scenario	Savings
Chat sessions (short turns)	3-5%
Coding sessions (file reads, JSON)	30-50%
Lockfiles	up to 81%
Subagent tasks	20-40%

Security Notes

• API key handling: Tamp forwards the x-api-key / Authorization header from the incoming request to upstream. It does not store, log, or read API keys.
• Local only: Tamp binds to localhost by default. It does not accept external connections unless you change the bind address.
• No telemetry: Tamp does not phone home, collect analytics, or make any outbound connections except to the configured upstream API.
• Fallback: Add Anthropic direct as a fallback model in OpenClaw. If Tamp is down, requests bypass it automatically.

Resources

• ~70MB RAM, <5ms latency per request
• No Python needed — all 7 stages run in Node.js
• Source (MIT) · tamp.dev · white paper