Your agent is reading noise. sctx stops paying for it.
Command output was written for humans with scrollback, not for a model with a context window. sctx wraps the commands your agent already runs and re-renders them token-minimally — then tells you exactly how much it saved.
Why use sctx
48% fewer tokens
Measured across 159K real wrapped commands — 99M raw tokens rendered down to 51M. Not a benchmark; actual work on developer machines.
Nothing is hidden
Every elision carries an explicit …+N marker, so the agent always knows something was omitted. Compression that silently drops lines is worse than none.
Zero workflow change
A hook rewrites covered commands transparently. You keep typing go test ./...; your agent receives the compact rendering.
Two commands and you are done
Prebuilt binaries for macOS, Linux and Windows. Statically linked, no runtime dependencies, and nothing to configure before it starts working.
Homebrew recommended
brew install synapctx/tap/sctxDownload a binary
Grab the darwin_arm64 (Apple Silicon) or darwin_amd64 (Intel) archive from Releases, then:
tar -xzf sctx_<version>_darwin_arm64.tar.gz
sudo install -m 0755 sctx sctxd /usr/local/bin/Go toolchain
Builds from source with a Go 1.26+ toolchain. Installs to $GOBIN, so it must be on your PATH.
go install github.com/synapctx/sctx/cmd/sctx@latestHomebrew recommended
brew install synapctx/tap/sctxDownload a binary
Grab the linux_amd64 or linux_arm64 archive from Releases, then:
tar -xzf sctx_<version>_linux_amd64.tar.gz
sudo install -m 0755 sctx sctxd /usr/local/bin/Go toolchain
Builds from source with a Go 1.26+ toolchain. Installs to $GOBIN, so it must be on your PATH.
go install github.com/synapctx/sctx/cmd/sctx@latestDownload a binary recommended
Grab the windows_amd64 or windows_arm64 archive from Releases, then, in PowerShell:
Expand-Archive sctx_<version>_windows_amd64.zip `
-DestinationPath $env:LOCALAPPDATA\Programs\sctx
# then add that directory to your PATHGo toolchain
Builds from source with a Go 1.26+ toolchain. Installs to $GOBIN, so it must be on your PATH.
go install github.com/synapctx/sctx/cmd/sctx@latestThen let your agents know about it
sctx works the moment it is installed — put it in front of any command. To have it applied automatically, run:
sctx setup --installThis detects which AI coding agents are on your machine and, for each one, writes a short instruction file describing what sctx is and when to use it. For Claude Code it also registers a hook, so commands are wrapped as they are issued: you and your agent keep writing go test ./..., and the compact output is what arrives.
It writes only where an agent has already left its own configuration, never creates one speculatively, and will not overwrite a file you have edited. Below is what it writes for each agent — to read before installing anything, or to follow by hand.
Your coding agent- Instruction file
~/.claude/CLAUDE.md- Document beside it
~/.claude/SCTX.md- What is added to it
- A one-line reference to
SCTX.md, between markers so it can be replaced in place later rather than duplicated — the document itself goes in the file beside it. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Write the document:
curl -fsSL https://synapctx.com/sctx/SCTX.md -o ~/.claude/SCTX.mdThen add the reference to ~/.claude/CLAUDE.md:
curl -fsSL 'https://synapctx.com/sctx/block.md?agent=claude' >> ~/.claude/CLAUDE.mdThis installs the instructions, not the hook. Doing it by hand tells your agent what sctx is, so it stops re-explaining compact output — but for Claude Code the PreToolUse hook is what wraps commands automatically, and only sctx setup --install registers it.
Appending is a one-off, and it assumes the agent is already installed: if the directory does not exist, creating it would leave a file nothing ever reads.
- Instruction file
~/.claude/CLAUDE.md- Document beside it
~/.claude/SCTX.md- What is added to it
- A one-line reference to
SCTX.md, between markers so it can be replaced in place later rather than duplicated — the document itself goes in the file beside it. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Write the document:
curl -fsSL https://synapctx.com/sctx/SCTX.md -o ~/.claude/SCTX.mdThen add the reference to ~/.claude/CLAUDE.md:
curl -fsSL 'https://synapctx.com/sctx/block.md?agent=claude' >> ~/.claude/CLAUDE.mdThis installs the instructions, not the hook. Doing it by hand tells your agent what sctx is, so it stops re-explaining compact output — but for Claude Code the PreToolUse hook is what wraps commands automatically, and only sctx setup --install registers it.
Appending is a one-off, and it assumes the agent is already installed: if the directory does not exist, creating it would leave a file nothing ever reads.
- Instruction file
%USERPROFILE%\.claude\CLAUDE.md- Document beside it
%USERPROFILE%\.claude\SCTX.md- What is added to it
- A one-line reference to
SCTX.md, between markers so it can be replaced in place later rather than duplicated — the document itself goes in the file beside it. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Write the document:
iwr https://synapctx.com/sctx/SCTX.md -UseBasicParsing -OutFile "$env:USERPROFILE\.claude\SCTX.md"Then add the reference to %USERPROFILE%\.claude\CLAUDE.md:
Add-Content -Path "$env:USERPROFILE\.claude\CLAUDE.md" -Encoding utf8 -Value (iwr 'https://synapctx.com/sctx/block.md?agent=claude' -UseBasicParsing).ContentThis installs the instructions, not the hook. Doing it by hand tells your agent what sctx is, so it stops re-explaining compact output — but for Claude Code the PreToolUse hook is what wraps commands automatically, and only sctx setup --install registers it.
Appending is a one-off, and it assumes the agent is already installed: if the directory does not exist, creating it would leave a file nothing ever reads.
Show me what goes in the file
Exactly these bytes, markers included — the same ones sctx setup writes:
<!-- BEGIN SYNAPCTX — managed by `sctx setup`; edits inside are replaced -->
@SCTX.md
<!-- END SYNAPCTX -->
The markers are not decoration. They are how sctx setup later recognises the block as its own and replaces it in place; without them a reinstall appends a second copy, and both load into every session from then on.
Using an agent that is not listed? What goes in the file is plain Markdown — put it wherever your tool reads its global instructions, and open an issue so detection can cover it. The document is also readable on its own at /sctx/SCTX.md.
Confirm the install and see the effective configuration with sctx version and sctx doctor.
Keep sctx and sctxd in the same directory — sctx watch looks for its helper beside its own executable, so a matched pair always wins over an older copy elsewhere on PATH.
Compress the noise, never the signal
sctx parses what it recognises and degrades safely when it does not. The guiding rule is that a wrong answer costs far more than a large one.
Tiered rendering
Each command renders through aggressive (structured parse) → relaxed (heuristic filtering) → verbatim. Any parse failure, panic or anomaly falls to the next tier. Output is never suppressed.
Exit codes preserved exactly
The wrapped command’s exit status passes through untouched, with signal forwarding intact. Your scripts and CI cannot tell sctx is there.
Failures stay loud
When a command fails, sctx compresses the surrounding noise and leaves the error intact. A stack trace is the one thing you never want summarised.
Measured, not claimed
sctx gain reports savings locally, per command and per repository. The same numbers roll up to your console so you can see where the context budget actually goes.
Pipeline aware
Commands still compress inside pipelines and && chains. sctx declines only where wrapping would be lossy — a downstream filter, a redirect, a subshell.
Offline costs nothing
Telemetry is fire-and-forget and strictly budgeted. With no network it spools locally and drains later; it never delays your output.
What it already understands
Recognised commands get a purpose-built renderer. Anything else passes through untouched, with JSON output compacted automatically.
Build, test and lint, whatever the language.
| Area | Commands with a dedicated renderer |
|---|---|
| Go | go test, go build, go vet, go run, go mod, go list, go get; golangci-lint |
| Python | pytest, ruff, mypy, pip |
| JavaScript | npm, pnpm, yarn |
Recursive search is the noisiest output a developer produces, and the most compressible.
| Area | Commands with a dedicated renderer |
|---|---|
| Search | rg, grep, find |
Listing and reading. Content that carries meaning is passed through, not compressed.
| Area | Commands with a dedicated renderer |
|---|---|
| Files | ls, tree, cat, head, tail, diff, du |
Version control, including the GitHub CLI — fetching a PR is version-control work.
| Area | Commands with a dedicated renderer |
|---|---|
| Git | status, log, diff, show, branch, blame, stash |
| GitHub CLI | gh |
What is running, locally or in a cluster.
| Area | Commands with a dedicated renderer |
|---|---|
| Containers | docker, docker compose |
| Kubernetes | kubectl |
Shell and remote work.
| Area | Commands with a dedicated renderer |
|---|---|
| Build & shell | make, curl, jq |
| Remote | ssh, rsync |
| Other | brew, mongosh |
Anything not listed still runs untouched — sctx never stands between you and a command it does not understand.
Where the tokens actually go
Live figures from every wrapped command sctx has reported, refreshed continuously. Not a benchmark and not a projection — sctx records both the raw output and what the agent received, so the difference is measured.
- 159K
- commands executed
- 99M
- raw output tokens
- 47M
- removed before your agent read it — 48%
Measured from real command runs across every organization on the platform, not a benchmark — and today that means our own machines, because SynapCTX is in open beta. Your figures will differ with your codebase and how noisy your tools are: a recursive search compresses enormously, a file dump barely at all, because sctx leaves output that carries meaning alone.
A number you can rerun, not one you have to trust
One command runs a fixed, documented set of commands against whatever repository you point it at — locally, and it sends nothing.
sctx bench --name synapctx/sctxAdd --format json for a stable, scriptable document (schemaVersion 1) instead of the table below. Every command runs against the repository already on disk; nothing is uploaded, and no telemetry is recorded for the run.
Captured 2026-09-04, sctx v0.7.0, darwin/arm64, against synapctx/sctx itself:
Command Raw Rendered Saved Tier
go build 0 0 0.0% verbatim
go vet 0 0 0.0% verbatim
go test 1.1K 13 98.8% aggressive
git status 25 3 88.0% aggressive
git log 817 529 35.3% aggressive
git diff 330 189 42.7% aggressive
grep 47.6K 3.4K 93.0% aggressive
ls 319 115 63.9% aggressive
find 4.0K 1.5K 62.0% aggressive
TOTAL 54.2K 5.7K 89.4%
tokens = bytes/4, a floorEach command runs twice — once raw, with no formatting at all, and once through sctx’s own pipeline in-process, the same code path a wrapped command uses. Tokens are estimated as bytes/4, which sctx treats as a floor rather than an average, so every percentage above understates rather than flatters. A command that prints nothing on a clean run, like go build or go vet, legitimately saves 0.0% — there is nothing to compress, not a failure to.
One developer, thirty days
The table above is a single run. This is thirty days of actual use on the same machine, from sctx gain --since 30d: 30,646 commands wrapped, 28.3M raw tokens rendered down to 6.0M — 78.8% saved. Most of that came from grep (13.9M tokens saved), then curl (5.2M), rg (1.7M), go test (801K) and find (448K).
That estate is one Go-heavy developer’s machine (n≈1), not a market average — your mix of commands will move the percentage more than anything else does.
Run it against your own repository and publish what you get — the table above is the entire output of one command, nothing curated out of it.
Free on its own. More with an account.
sctx is complete as a local tool and always will be. SynapCTX is a separate product it can report into — useful, and entirely optional.
sctx alone
Free forever
- Every formatter and every command
- The hook,
sctx setup, all tiers sctx gain— your savings, stored locally- No account, no telemetry you did not opt into
sctx with SynapCTX
Adds the org-wide view
- Savings roll up per repository and per developer in your dashboard
- Your agent can ask about code across every repository, not just the open one
sctx watchkeeps your uncommitted work visible to retrieval, so answers describe the code in front of you rather than the last commit- Decisions recorded once are recalled by a teammate's agent months later
If you want the dashboard side, every plan starts with a 14-day trial and no card. If you only ever want the free tool, that is a complete and supported way to use sctx — see what a plan adds.
Straight answers
Is sctx really free?
Yes — free and MIT-licensed, with no account required for anything on this page. It is not a plan benefit that disappears if a subscription lapses: the tool, the formatters, the hook and your local savings history are yours whether or not you ever create a SynapCTX account.
Can it hide something I needed?
It is built specifically to avoid that. Every omission is marked with a count, a render that is empty or not actually smaller is rejected in favour of the raw output, and anything it cannot parse confidently passes through verbatim.
Does it slow my commands down?
Rendering is measured in milliseconds for typical output, and telemetry never blocks delivery. The dominant cost stays the command itself.
Can I turn it off for one command?
Yes. sctx -- <command> forces verbatim passthrough, and an environment switch disables rewriting entirely when you want the raw firehose.
Does my code leave my machine?
No. Telemetry records what was saved — command name, token counts, timings — never your command output, arguments, or source.
How do I get it?
brew install synapctx/tap/sctx, go install github.com/synapctx/sctx/cmd/sctx@latest, or a prebuilt archive from Releases — see the install section. Source is on GitHub under the MIT licence.
Do I need a SynapCTX account?
Not for anything on this page. An account adds the org-wide half — savings rolled up in a dashboard, retrieval across every repository, and sctx watch keeping your uncommitted work visible to it. Without one, nothing about sctx degrades; you simply keep your savings history locally, where sctx gain reads it.
Stop spending context on formatting
One command, no account, and your agent stops reading output nobody chose.
brew install synapctx/tap/sctxWant the savings rolled up across your team, and retrieval over every repository? SynapCTX plans start with a 14-day trial and no card.