Chisle

Chisle is a Claude Code plugin that makes Claude cheaper to run without making it dumber. It cuts what Claude writes: no filler, no hedging, no speculative abstractions, just the smallest code that works. It also cuts what Claude reads: a PostToolUse hook trims oversized tool output by ~48% before it re-enters the context window, where it would be re-billed on every later request. In agent-loop tests Claude with Chisle passes the same tasks as Claude without it. One npx chisle installs it, and the same ruleset ships to Pi, Cursor, Codex, Gemini, Copilot, OpenCode, Antigravity and four more agents. Every number here comes from committed raw transcripts, including the runs where it lost.

---

"Implement an order state machine covering created, paid, shipped, delivered, cancelled and refunded, with the legal transitions enforced and invalid ones rejected." Same model, same prompt, one difference: the injected ruleset. Both answers are the verbatim committed output from raw-nov-sidebyside/large-s2:

A preamble, a custom exception class, docstrings on every method, an extra can_transition_to helper:

class OrderStateError(Exception):
    """Raised when an invalid state transition is attempted."""
    pass

class Order:
    # Define valid transitions: state -> list of allowed next states
    VALID_TRANSITIONS = { … }
    def transition_to(self, next_state):
        """Transition to the next state. Raises OrderStateError if invalid."""
    def can_transition_to(self, next_state):
        """Check if a transition is allowed without performing it."""

…plus usage, tests, printed output and a recap of the transitions.

Code first, no preamble: one table of legal moves, one method that enforces it:

class OrderStateMachine:
    TRANSITIONS = {
        "created": {"pay", "cancel"},
        "paid": {"ship", "refund", "cancel"},
        …
    }
    def transition(self, event):
        if event not in self.TRANSITIONS[self.state]:
            raise ValueError(f"Cannot {event} from {self.state}. …")
        self.state = self.STATE_MAP[(self.state, event)]
        return self.state

Then a short usage block.

Same behaviour, under half the tokens. caveman wrote 604 and ponytail 747 on the same prompt.

What it compresses

axis	what	how
Output: prose	filler, hedging, manufactured structure	zero-fluff ruleset, injected per session
Output: code	speculative abstractions, unrequested boilerplate	YAGNI efficiency ladder
Input: context	oversized tool output flooding the window	Claude PostToolUse, Pi tool_result, OpenCode plugin, Copilot CLI postToolUse: scrub, elide, dedup, plus prevention rules
Input: cache	a big context re-bought after the prompt cache expires	Claude Code: on the first prompt after an hour-plus break with 150k+ tokens of context, one line suggests /compact or /clear. On the maintainer's sessions those re-writes were 14% of spend
Input: tool schemas	schemas of tools you never call, re-sent on every request	npx chisle tools reports tool schemas and skill descriptions vs. your own calls; tools trim denies the unused heavy tools and lists unused skills name-only, tools restore undoes it. On the maintainer's Claude Code: ~5k tokens per request, ~15k with the rarely used Artifact
Input: MCP	oversized MCP tool results in any agent	npx chisle mcp wrap: a proxy in front of each stdio MCP server (Cursor, Windsurf, Cline, Kiro, Gemini, Qwen Code, Copilot CLI, Antigravity, Codex, Copilot in VS Code)

Where each one attaches to a session:

flowchart LR
    subgraph S["Session start"]
        H1["Ruleset injection<br/>once per active session"]
    end
    subgraph T["Every turn"]
        H2["Mode tracking<br/>Claude + Pi"]
    end
    subgraph L["Every tool call"]
        H3["PostToolUse / tool_result<br/>scrub → elide → dedup"]
    end

    H1 --> M(["Model"])
    H2 --> M
    M -->|writes| O["Output:<br/>terser prose,<br/>YAGNI-first code"]
    M -->|calls a tool| TOOL[["Bash / grep / web / extension tools"]]
    TOOL -->|raw output| H3
    H3 -->|"compressed, rebuilt into<br/>the tool's own shape"| M

    RE["Read / Edit / Write"] -.->|"never touched,<br/>exact bytes feed later edits"| M

    style M fill:#1f2937,stroke:#d78a3c,color:#e6edf3
    style O fill:#14532d,stroke:#2da44e,color:#e6edf3
    style H3 fill:#1f2937,stroke:#2da44e,color:#e6edf3
    style RE fill:#3f1d1d,stroke:#cf3b3b,color:#e6edf3

The loop on the right is the input axis: tool output is billed again on every later request in the session, so shrinking it once pays repeatedly. Read, Edit, and Write are deliberately outside it.

---

Install

One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Antigravity, Codex, Gemini, Copilot, Copilot CLI, OpenCode, Hermes) and wires each one. --uninstall puts everything back. npx chisle mcp wrap extends tool-output compression to MCP servers in any agent (details).

npx chisle

# or via curl
curl -fsSL https://raw.githubusercontent.com/JayPokale/Chisle/main/install.sh | bash

# Windows
irm https://raw.githubusercontent.com/JayPokale/Chisle/main/install.ps1 | iex

Preview first with npx chisle --dry-run, scope with --only claude or --only pi, see everything with npx chisle --help. Remove with npx chisle --uninstall.

Upgrading, per-agent setup, --stats and config: docs/usage.md.

---

Benchmarks

Same model, same prompts, one difference: the injected ruleset. Lower = leaner. Chisle is the leanest on every row.

Claude Code, side by side (Haiku 4.5, 25 live prompts in one run, tools off, raw cells):

This is the beginning of the README. Read the rest at the original. Read the full README ↗