# CULP (Claude Usage Limits): complete documentation
Generated from the same source the documentation site renders.
Independent product, not affiliated with or endorsed by Anthropic.
========================================================================
# Welcome
URL: https://claudeusagelimits.com/docs/start/welcome/
Summary: What CULP is, what it changes about a Claude Code session, and what it deliberately does not touch.
========================================================================
CULP is a Claude Code plugin and a cross-platform CLI. It works on the harness
around Claude Code: the hooks it runs, the tools it loads, and the context it
carries from turn to turn. It cuts what that harness costs.
It does not change the model you selected, and it does not raise a limit
Anthropic set. Your limit is your limit. CULP reduces the waste inside it, so
the same limit carries more work.
## The one fact everything follows from
An output token costs roughly five times an input token. Most of what a coding
session spends is output: the model writing source, and the model repeating
source it has already read so a tool can find it again.
Every feature in CULP is an attack on one of those two costs.
- **Compact decoding** replaces the source you write with a short notation that
a server expands into real code before the file is written. You pay for the
notation; the file gets the code.
- **The patch tool** lets you name the region of a file to replace instead of
quoting it back. You never re-emit text the file already has.
- **Delegated search** answers `Glob` and `Grep` in a separate cheap session and
returns only the ranked matches, so a thousand-line result never lands in
your context.
- **The CLAUDE.md splitter** turns an oversized memory file into a compact root
plus documents that load only when they are needed.
- **MCP relocation** moves servers you rarely call out of the loaded tool list
and into a CLI you can invoke when you actually need them.
## What it changes, it changes reversibly
MCP registrations are written to disk before they are moved. A `CLAUDE.md` is
backed up before it is split. A decode that cannot happen blocks the write
instead of guessing at it.
Nothing is authored on your behalf. A patch replaces a region that is already in
your file, byte for byte, and a region CULP cannot tell apart is refused by name
rather than guessed at.
## Where to go next
Install it, then read [Understanding CULP](/docs/start/understanding/) so the
messages it prints make sense the first time you see one.
========================================================================
# Install
URL: https://claudeusagelimits.com/docs/start/install/
Summary: One line on macOS, Linux or Windows, then three commands to authorize the machine and install the plugin.
========================================================================
CULP is two pieces: a CLI called `culp`, and a Claude Code plugin that the CLI
installs for you. The one-line installer places the CLI; `culp setup` does the
rest.
## macOS and Linux
curl -fsSL https://api.claudeusagelimits.com/install.sh | bash
## Windows
irm https://api.claudeusagelimits.com/install.ps1 | iex
Windows is a first-class target, not a courtesy: the CLI's test suite runs on a
real Windows runner in CI, because the bugs that only appear there are the ones
that cannot be reproduced anywhere else.
## Then, on every machine
1. `culp login` opens your browser and authorizes this machine. The
authorization lasts 180 days and there is no refresh token; when it expires,
log in again.
2. `culp setup` downloads the plugin bundle and points Claude Code at it. It
verifies every step by re-reading what Claude Code reports, because
`claude plugin install` is a no-op on an already-installed plugin and
"already exists" is not proof.
3. `culp doctor` checks all of it and names anything that is wrong.
## What lands on your machine
Everything CULP stores is under `~/.culp`:
| File | What it holds |
| --- | --- |
| `device.key` | This device's Ed25519 private key. It never leaves the machine. |
| `device.json` | The device identity the key is bound to. |
| `auth.json` | The device's access token. Deliberately no email, no password, no MAC, no refresh token. |
| `config.json` | The API URL and endpoint overrides. |
| `update.json` | The cached release manifest. |
| `motd.json` | The cached message of the day. |
Set `CULP_HOME` to move all of it somewhere else. Every path above is derived
from that one variable.
## Keeping it current
`culp update` synchronizes the whole installation, not just the wheel: the CLI
and the plugin carry independent versions, and a plugin-only release is the
normal case.
The wheel half never installs in its own process. It spawns a detached process
that waits for the current `culp` to exit and only then runs the installer, on
every platform, because replacing a tool environment underneath a running
process loses every module it has not imported yet. So the command reports a
*scheduled* install rather than a version; `culp --version` in a later session
is the confirmation.
A session that starts while an update is published tells you so, and you can ask
Claude to run `culp update` for you rather than doing it yourself.
========================================================================
# Understanding CULP
URL: https://claudeusagelimits.com/docs/start/understanding/
Summary: The four messages the plugin can put in front of you, and what each one actually means.
========================================================================
CULP changes two ordinary things: how source files get written, and where
`Glob` and `Grep` answers come from. Both changes are invisible until something
goes wrong, and both produce messages that are easy to misread.
## A write either succeeds as real source, or does not happen
When Claude writes compact source, the plugin's `PreToolUse` hook decodes it
**before** the mutation runs and hands the real source back as the tool's
arguments. So a file never contains compact syntax, not even briefly, and not to
any linter or language server that reads it a moment later.
The consequence that matters: a decode that fails **blocks the write**. Nothing
lands on disk, and the tool call comes back with a named reason.
There is no outcome in which compact syntax silently becomes the final content
of a file. If you see one, that is a bug worth reporting to
support@claudeusagelimits.com with the receipt id.
## The four messages
**A receipt.** `CULP applied python->thing.py (18 lines, syntax valid, id
9f6e8007)`. The write happened and the file holds decoded source. The receipt
never contains the generated code, so Claude has not seen the file it just
wrote: it has to read it before editing it, whatever the tool result says about
that not being necessary.
**A refusal.** `CULP decode failed for thing.py: decode_error: ...`. The
mutation was blocked and nothing was written. Either fix the compact expression
or write ordinary source for that file.
**A verification warning.** `CULP warning: thing.py still contains compact CULP
source after this tool call`. The decode was overridden by something else. In
practice this means another plugin's `PreToolUse` hook answered last and its
answer won, because `updatedInput` does not compose. Rewrite the file with
ordinary source.
**A search answer.** A `Glob` or `Grep` result that arrives flagged as an error
but reads like a normal answer. It is a normal answer. Blocking the native tool
requires a deny decision, and Claude Code delivers every deny with an error
flag, so the wording says in words that the search actually ran.
## Ordinary source is never touched
Content that is not compact passes straight through and never goes near the
network. Two separate gates decide that: one tuned for recall, which decides
whether to call the decoder at all, and one tuned for precision, which decides
whether a failure is allowed to block the write. A broken CULP credential
therefore cannot stop you editing files normally.
## When the plan or the credential is the problem
A session that starts on a free plan is told so, once, and the paid surfaces
simply are not used. A session whose device credential is locally unusable is
also told so, before the first mutation rather than after it, because a refused
write costs a turn.
Run `culp doctor` for the diagnosis. It is the only command that makes a network
call to answer, and an unreachable API is reported as unknown rather than as a
failure.
========================================================================
# Compact decoding
URL: https://claudeusagelimits.com/docs/features/compact-decoding/
Summary: The compact notation Claude writes instead of source, the 28 languages it covers, and where it is decoded.
========================================================================
Writing source is where a coding session spends most of its output budget. The
`culp-emmet` skill has Claude write a short, Emmet-like notation instead, and
the plugin expands it into real source before the file is written.
## How a write actually happens
1. Claude calls `Write` or `Edit` with compact content.
2. The plugin's `PreToolUse` hook takes the compact content out of the tool
call and posts it to the decoder, signed with this device's key.
3. The decoder picks a language by explicit hint, then by its own confidence,
then by file extension, parses the notation, and returns real source plus a
receipt.
4. The hook hands the real source back as the tool's arguments, replacing only
the field that held the compact content and preserving every other argument.
5. The tool writes decoded source.
Decoding happens **before** the mutation, never after it. An earlier design
rewrote the file afterwards, which left a window in which a language server read
the compact text and reported a screenful of deterministic errors against it.
## The languages
Twenty-eight, each with its own decoder module and its own reference:
Ada, C, C++, C#, COBOL, CSS, Dart, Go, HTML, Java, JavaScript, JSX, Kotlin, Lua,
Perl, PHP, Python, R, Ruby, Rust, SCSS, SQL, Swift, TypeScript, TSX, Visual
Basic, XML, Zig.
Claude loads the reference for a language before writing compact source in it,
and writes ordinary source for anything not on the list. Compact syntax is never
invented for a language CULP does not cover.
## What it costs you to have it
A decode is one HTTPS round trip on a file write, and it needs an active
subscription. If the decoder cannot be reached, the write is refused rather than
guessed at, and you write ordinary source instead.
Shell redirection is not covered. `Write` and `Edit` are tool calls the plugin
can intercept; `printf 'x' > file.py` in a Bash call is not decoded, and content
written that way lands exactly as typed.
## Receipts
Every successful decode prints one line: the language, the file, the line count,
whether the generated source parses, and an id. The receipt never contains the
generated code, which is the whole point: putting the output back in the
transcript would spend exactly the tokens the feature saves.
The consequence is worth knowing: after a compact write, Claude has not seen the
file it just wrote. It has to read it before editing it.
========================================================================
# The patch tool
URL: https://claudeusagelimits.com/docs/features/patch-tool/
Summary: Editing a file by naming the region instead of quoting it back, and every reason it can refuse.
========================================================================
`Edit` asks for `old_string` to reproduce the target text byte for byte. That is
the one field where a model re-emits, as output tokens, text it already paid for
as input tokens. A thirty-line `old_string` costs thirty lines of output and
carries no information the file did not already have.
The `patch` tool removes that repetition. Claude names the region; the tool
reads the region off disk and replaces it.
## Naming a region
Two selectors, and only one may be used at a time.
| Selector | Example | Means |
| --- | --- | --- |
| `lines` | `"42:58"` | Lines 42 through 58 inclusive, counted by newline. |
| `regex` | `{"pattern": "def run\\(.*?\\n\\n", "flags": "s"}` | The single region the expression matches. |
Lines are counted by `\n` and nothing else. A form feed in a C or Emacs Lisp
source would otherwise shift every line number, because the usual line splitter
also breaks on `\f`, `\v` and several Unicode separators.
## It runs on your machine
The tool is served by `culp mcp`, a stdio server inside the CLI that Claude Code
starts. It is local because a remote server cannot read your disk, and routing
the file's text through the model's output would re-emit exactly what the
feature avoids.
The tool cannot check that the file was read first, because it is a separate
process with no view of the transcript. `Edit` can and does. That is a real
reduction in safety, taken deliberately for the tokens, and the receipt is what
makes a mistargeted region visible. Read the receipt.
## What it will not do
Nothing is authored. The region replaced is always a substring of the file, byte
for byte. Regions are never widened, because widening changes what the
replacement has to contain, and a region that cannot be told apart is refused by
name rather than guessed at.
The replacement is spliced at the resolved offsets, never searched for. An
earlier version applied it by string replacement, which found the *first* copy
of the region's text, so a line range could resolve correctly and then edit a
different line whenever the file repeated itself.
## Refusals
| Reason | What happened |
| --- | --- |
| `line_out_of_range` | The range names a line the file does not have. |
| `no_match` | The expression matched nothing. |
| `ambiguous_match` | The expression matched in more than one place. |
| `divergent_matches` | The matches disagree about what the region is. |
| `invalid_regex` | The pattern did not compile. |
A refusal costs a turn and never a file. The replacement is encoded in full
first, written to a sibling temporary, and only then moved over the original, so
a failure part-way through cannot leave the file truncated. Symlinks are
followed rather than replaced.
## Text handling
The stream is decoded as UTF-8 by the tool itself rather than by the platform,
because a piped standard input is otherwise decoded with the system locale. On a
Windows console that turned a Japanese character into three wrong ones, and
turned `é` into mojibake silently, under a receipt reporting success.
Line breaks inside the replacement are converted to the file's own convention. A
file with no newline, or one that already mixes both, has shown no convention
and gets nothing imposed on it.
========================================================================
# Delegated search
URL: https://claudeusagelimits.com/docs/features/search/
Summary: Why Glob and Grep answers arrive flagged as errors, and what actually ran.
========================================================================
A `Grep` over a large repository can return thousands of lines, and every one of
them lands in the session's context whether it was relevant or not. CULP stops
the parent session running its own search.
## What happens instead
The plugin's `PreToolUse` hook denies the native tool and answers the same
question from a separate, cheap Haiku session. That session runs the search,
ranks and filters what it found, and returns only the matches worth having.
The answer names CULP. It has to: a caller that discovers an unattributed
rewrite of its own tool results reads it as prompt injection, which is worse
than knowing.
Every delegated answer arrives with an error flag. Blocking the native tool
requires a deny decision, and Claude Code marks every deny as an error. The
wording therefore says in words that the search ran and that the result below is
real.
## What it does not do
If the delegated session cannot start, the hook exits without a decision and the
native `Glob` or `Grep` runs normally. Search never becomes unavailable because
CULP is having a bad day.
The output budget is enforced in code rather than asked for in a prompt, so a
verbose sub-agent cannot spend your context by ignoring an instruction.
## What it costs
A separate session, on a smaller model, whose whole job is to read search
results so your session does not have to. The comparison that matters is not
"free versus not free": it is a few hundred tokens of ranked matches against
several thousand lines of raw ones.
========================================================================
# The CLAUDE.md splitter
URL: https://claudeusagelimits.com/docs/features/claude-md-splitter/
Summary: What happens when a memory file grows past 2,000 characters, and how to watch it.
========================================================================
`CLAUDE.md` is loaded into context at the start of every session and stays there
for all of it. A long one is a fixed tax on every turn, paid whether or not any
of it was relevant.
When CULP sees a `CLAUDE.md` over 2,000 characters, it splits it into a compact
root plus on-demand documents under `.claude/md/`, and the root points at them.
## It never runs in the hook
Claude Code has no asynchronous command hook, so a `SessionStart` hook delays
the session for exactly as long as it runs. Measured: a 12-second hook turned a
2-second `claude -p` into a 20-second one. Running an inference there would
freeze the session for the whole split.
So the hook only claims the file and starts a background worker. The split runs
in its own process, and your session continues immediately.
On Windows the worker takes a console window, so you can watch it. On macOS and
Linux the same transcript goes to a log file under `~/.culp/claude-md-splits/`,
and the session start message tells you which one.
## Your original is never destroyed
The source is backed up before anything replaces it, and the replacement is
atomic. A failed split leaves the file byte-identical.
A generated root carries a marker comment, which is how a second session knows
not to split it again.
## Reporting
The split is dispatched at session start and its outcome is reported once, on
your next prompt. Ending a session cancels the workers it started.
If a split fails, that counts against the exact content it failed on, so a file
that cannot be split is not retried for ever in every future session. Fix the
file, or change it, and the count resets.
========================================================================
# MCP relocation
URL: https://claudeusagelimits.com/docs/features/mcp-relocation/
Summary: Moving rarely-used MCP servers out of the loaded tool list and into a CLI, without losing them.
========================================================================
Every MCP server registered with Claude Code contributes its tool definitions to
the context of every session, whether you call them or not. A handful of
servers is a meaningful standing cost.
CULP moves eligible servers out of Claude's loaded configuration and into
private `mcp-cli` config files under `~/.culp/mcp/`. They stay available; they
stop being loaded.
## Nothing disappears
The original registrations are written to disk before they are moved. One
command puts them back the way they were.
The session is told which servers were relocated and, for each, the tools it
exposes: the name, one line of description, and the required argument names.
A relocated server that Claude has never heard of is a server Claude will never
plan around. Naming the tools is what keeps them usable, and leaving out the
JSON schemas is what keeps that cheap.
## Calling one
Through `mcp-cli`, from Bash or PowerShell. The session start message prints the
exact command lines with the right config file already filled in.
One rule matters and the message repeats it: every option must follow the
subcommand. An option placed before it is discarded, and `mcp-cli` then silently
loads its own bundled server inventory instead of yours.
## What it costs
The tool catalogue is discovered once and cached, keyed by the content of your
configuration, with a per-server timeout and a total startup budget. A server
that fails to answer is remembered as having failed, so it is not retried on
every session start.
========================================================================
# The definitions tool
URL: https://claudeusagelimits.com/docs/features/definitions/
Summary: Reading the enclosing definitions of any public GitHub repository without cloning it into your context.
========================================================================
`definitions` is a remote MCP tool at `mcp.claudeusagelimits.com`. Give it a
public GitHub repository and it returns the parsed, enclosing definitions from
its source: the shape of the code rather than all of it.
## Why it is not a clone
Reading an unfamiliar library usually means fetching far more text than the
question needed. `definitions` shallow-clones the repository server side, parses
it with Tree-sitter, and returns only the definitions that enclose what you
asked about.
The clone happens on the server. Nothing lands in your working directory and
nothing lands in your context except the answer.
## Connecting
Claude Code connects to it directly over OAuth 2.1. There is no stdio proxy to
install and no token to paste: the first call opens a browser, and the resulting
access token is audience-bound and refreshable.
The token authenticates you. It does not carry your subscription: the tools
check that separately, so a plan change takes effect on the next call rather
than at token expiry.
========================================================================
# Session notices
URL: https://claudeusagelimits.com/docs/features/session-notices/
Summary: The message of the day and the update notice, where they come from, and how to switch them off.
========================================================================
Two things can appear when a session starts, above your first prompt. Both are
addressed to you and neither is part of Claude's context.
## The message of the day
A short line CULP's operator can publish at any time: a launch note, an incident,
a change worth knowing about. It is fetched from the API, cached for thirty
minutes, and printed once per session.
It is deliberately not given to Claude. A model told about an announcement acts
on it, and an announcement is not an instruction.
If the API cannot be reached, the last message you were shown is used rather
than silence, because a failed request is not evidence that there is nothing to
say. If there has never been one, nothing is printed at all.
Set `CULP_DISABLE_MOTD=1` to switch it off.
## The update notice
When a newer CULP is published, the session says so and names both versions:
```
CULP update available: CLI 0.8.1 (you have 0.8.0). Run `culp update`, or tell
Claude to do it for you.
```
The plugin and the CLI carry independent versions, and a plugin-only release is
the normal case, so both halves are compared. Claude is told about this one,
because you were just invited to ask it to run the command.
What it will do if you ask: run `culp update`, which installs the CLI wheel and
synchronizes the plugin bundle. The wheel install is detached and starts only
after the current process exits, so the command reports a *scheduled* install
rather than a new version. `culp --version` in a later session is the
confirmation.
Set `CULP_DISABLE_UPDATE_NOTICE=1` to switch it off.
## What they cost
One `culp` process at session start, which the plugin was already spending on
the plan and credential check. Nothing is printed when there is nothing to say.
========================================================================
# CLI reference
URL: https://claudeusagelimits.com/docs/reference/cli/
Summary: Every culp command, what it touches, and which ones make a network call.
========================================================================
## Commands
| Command | What it does |
| --- | --- |
| `culp login` | Authorizes this machine through your browser. 180 days, no refresh token. |
| `culp logout` | Revokes this device. `--local-only` forgets the credential without telling the server. |
| `culp setup` | Installs the Claude Code plugin and points it at the right marketplace, verifying each step. |
| `culp update` | Synchronizes the whole installation: the CLI wheel and the plugin bundle. |
| `culp status` | Whether this device is active, inactive, revoked or logged out, and what plan it is on. |
| `culp doctor` | Every check at once, with the value each one found. |
| `culp version` | The installed version and the cached latest one. No network call. |
| `culp motd` | The operator's message of the day, from cache unless it is stale. |
| `culp session-notice` | Everything a session start needs, in one process. Run by the plugin, not by hand. |
| `culp decode` | The decode hook. Run by the plugin, not by hand. |
| `culp mcp` | The local MCP server that serves the `patch` tool. Started by Claude Code. |
Add `--json` before any command for machine-readable output, and
`--no-update-check` to skip the version check for that invocation.
## Which ones use the network
`login`, `logout`, `setup`, `update`, `status`, `doctor`, `decode`, and the
refresh half of `motd`. Everything else answers from disk.
`culp version` never makes a request: it reads the cached manifest, which is why
it is safe to call from a hook.
## Environment
| Variable | Effect |
| --- | --- |
| `CULP_HOME` | Where all state lives. Default `~/.culp`. |
| `CULP_API_URL` | The API base URL. |
| `CULP_REQUEST_TIMEOUT` | Request timeout in seconds. Default 15. |
| `CULP_UPDATE_CHECK_INTERVAL` | Seconds between update checks. Default 900. |
| `CULP_DISABLE_UPDATE_CHECK` | Set to `1` to never check for updates. |
| `CULP_MOTD_INTERVAL` | Seconds between message-of-the-day refreshes. Default 1800. |
| `CULP_DISABLE_MOTD` | Set to `1` to never show the message of the day. |
| `CULP_DISABLE_UPDATE_NOTICE` | Set to `1` to never show the update notice. |
| `CULP_PLAN_CONTEXT` | Set to `0` to stop the session hook resolving the plan. |
========================================================================
# Troubleshooting
URL: https://claudeusagelimits.com/docs/reference/troubleshooting/
Summary: Every named failure CULP can report, what caused it, and what to do next.
========================================================================
Start with `culp doctor`. It runs every check and prints the value each one
found rather than a pass or a fail, which is usually enough on its own.
## A write was refused
| Reason | Cause | Next step |
| --- | --- | --- |
| `not_logged_in` | No credential on this machine. | `culp login` |
| `credential_expired` | The 180-day authorization ran out. | `culp login` |
| `device_identity` | The stored identity no longer matches this machine. | `culp login` |
| `subscription_required` | No active plan. | Subscribe from your dashboard. |
| `unauthorized` | The device was revoked. | `culp login` |
| `api_unreachable` | The decoder could not be reached. | Check the network. Ordinary source still works. |
| `invalid_response` | The decoder answered something unexpected. | Report it with the file and the time. |
| `decode_error` | The compact expression is wrong for that language. | Fix it, or write ordinary source. |
A refused write costs a turn and never a file. Nothing was written, so there is
nothing to clean up.
## A patch was refused
`line_out_of_range`, `no_match`, `ambiguous_match`, `divergent_matches` and
`invalid_regex` all mean the region could not be identified without guessing.
See [the patch tool](/docs/features/patch-tool/). Name a narrower region, or
fall back to `Edit`.
## A file still contains compact source
`CULP warning: thing.py still contains compact CULP source after this tool call`
means another plugin's hook answered after CULP's and its answer won. Rewrite the
file with ordinary source. If it keeps happening, the other plugin's
`PreToolUse` hook is competing for the same tools.
## A search answer looks like an error
It is not. See [delegated search](/docs/features/search/).
## Nothing seems to be happening at all
Check the plan: on a free plan the paid surfaces answer with a payment-required
status and the plugin tells the session, once, not to use them.
Then check the credential with `culp doctor`. A device whose credential is
locally unusable is reported at session start, before the first write rather
than after it.
## Still stuck
support@claudeusagelimits.com. Include the output of `culp doctor` and, if a
write was involved, the receipt id from the message.
========================================================================
# Plans and billing
URL: https://claudeusagelimits.com/docs/account/plans/
Summary: What $9.99 a month buys, what the starter price means, and how refunds work.
========================================================================
One paid plan, one price.
## The price for starters
$9.99 USD a month. That is the price for starters: the people who subscribe
before the product has proven itself commercially. The public price is expected
to rise to $19.99.
Your price is locked at the rate you subscribed at, for as long as the
subscription stays active. It does not change when the public price does.
If you cancel and come back later, you pay the price of the day.
## What it includes
Everything. There is no tier above this one and nothing is metered:
- compact decoding across 28 languages
- the `patch` tool
- delegated `Glob` and `Grep`
- the `CLAUDE.md` splitter
- MCP relocation into `mcp-cli`
- the `definitions` tool on any public GitHub repository
- Windows, macOS and Linux, up to three authorized devices
## No free trial
There is not one. The refund window is what stands in for it: ask within 30 days
of your first payment and you get it back, no reason needed. Renewals have a
14-day window.
Request a refund from your dashboard, or write to
billing@claudeusagelimits.com.
## Cancelling
From the billing portal, linked on your dashboard, at any time. You keep access
until the end of the period you have already paid for.
## Devices
Three active devices at once. Each authorization lasts 180 days, and you can see
and revoke them from your dashboard: revoking takes effect immediately rather
than at token expiry, which is the point of having the button at all.
========================================================================
# Privacy and data
URL: https://claudeusagelimits.com/docs/account/privacy-and-data/
Summary: What CULP sends, what it stores, and the one thing it deliberately does not log.
========================================================================
The short version: CULP does not log your usage. There is no record of what you
decoded, what you searched for, or what you edited.
## What leaves your machine
**On a compact write.** The compact content, the tool name, the target file
path, and the kind of mutation. That is what the decoder needs to pick a
language and expand the notation. The result is returned and not retained.
**On a status or plan check.** A signed request carrying this device's id and
nothing about you.
**On a search.** Nothing leaves your machine to CULP. The delegated session runs
locally against your files.
**On a patch.** Nothing. The tool is a local process; there is no network call,
no decoder and no language detection.
## What is stored
| Where | What |
| --- | --- |
| Your machine | The device key, the device identity, the access token, the cached manifest and message of the day. All under `~/.culp`. |
| The API | Your email, your Stripe customer relationship, and one row per authorized device: its public key, platform, architecture and timestamps. |
| The mail gateway | Delivery metadata for messages we sent you: time, recipient, subject, provider id, result. No bodies. |
The device credential deliberately excludes your email, your password, your MAC
address and any refresh token.
## Deleting it
Write to privacy@claudeusagelimits.com from the address on the account. See the
[privacy policy](/privacy/) for the full statement.
========================================================================
# Support
URL: https://claudeusagelimits.com/docs/account/support/
Summary: Where to write, what to include, and how quickly you will hear back.
========================================================================
## Where to write
| Subject | Address |
| --- | --- |
| Something is broken | support@claudeusagelimits.com |
| Payments, invoices, refunds | billing@claudeusagelimits.com |
| Your data, deletion requests | privacy@claudeusagelimits.com |
| Anything else | hello@claudeusagelimits.com |
Or use [the contact form](/contact/), which reaches the same place.
## What to include
For anything involving a write or a search:
1. The output of `culp doctor`. It is the single most useful thing you can send,
and it prints values rather than verdicts.
2. The receipt id, if a CULP message named one.
3. What you expected the file to contain, and what it contained instead.
Do not send us the file if it is private. The path and the receipt id are
usually enough, and we would rather not have it.
## How quickly
CULP is a small operation. A reply within one business day is the intent, and
billing questions are answered first because they cost you money.
## Reporting something that looks wrong
If a write ever leaves compact syntax on disk without a warning, that
contradicts a guarantee this product makes, and we want to know within minutes
rather than eventually. Mail support with the receipt id.
========================================================================
# FAQ
URL: https://claudeusagelimits.com/docs/account/faq/
Summary: The questions people actually ask before subscribing.
========================================================================
## Does CULP change the model I asked for?
No. CULP edits the harness around Claude Code: what a turn costs in context and
in output tokens. The model you selected is the model that answers.
## Does it raise my Claude limit?
No. Your limit is set by Anthropic. CULP reduces the waste inside it, so the same
limit carries more work.
## Is it affiliated with Anthropic?
No. CULP is an independent product, not affiliated with or endorsed by Anthropic.
Claude is a trademark of Anthropic.
## Is there a free trial?
No. There is a 30-day refund window on your first payment instead.
## Does it work on Windows?
Yes, and the CLI's test suite runs on a real Windows runner in CI. Git Bash,
WSL, PowerShell and the classic console are all supported.
## What happens if the API is down?
Ordinary editing is untouched: content that is not compact never goes near the
network. A compact write is refused rather than guessed at, and you write
ordinary source until it comes back.
## Can I use it on more than one machine?
Three at a time. See them, and revoke them, from your dashboard.
## What if I cancel?
You keep access until the end of the period you paid for. Your account and your
devices stay; only the entitlement lapses.