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
~/.kilocode/rules/synapctx.md- What is added to it
- The instruction text itself, between markers. Kilo Code has no verified
@fileinclude mechanism, so a reference would be a line that silently loads nothing — the text goes in directly instead. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Append the block to ~/.kilocode/rules/synapctx.md:
curl -fsSL 'https://synapctx.com/sctx/block.md?agent=kilocode' >> ~/.kilocode/rules/synapctx.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
~/.kilocode/rules/synapctx.md- What is added to it
- The instruction text itself, between markers. Kilo Code has no verified
@fileinclude mechanism, so a reference would be a line that silently loads nothing — the text goes in directly instead. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Append the block to ~/.kilocode/rules/synapctx.md:
curl -fsSL 'https://synapctx.com/sctx/block.md?agent=kilocode' >> ~/.kilocode/rules/synapctx.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%\.kilocode\rules\synapctx.md- What is added to it
- The instruction text itself, between markers. Kilo Code has no verified
@fileinclude mechanism, so a reference would be a line that silently loads nothing — the text goes in directly instead. That is 4184 bytes loading into every session, which is why it is short.
Do it by hand
Append the block to %USERPROFILE%\.kilocode\rules\synapctx.md:
Add-Content -Path "$env:USERPROFILE\.kilocode\rules\synapctx.md" -Encoding utf8 -Value (iwr 'https://synapctx.com/sctx/block.md?agent=kilocode' -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 — token-optimized command output
`sctx` runs a developer command and re-renders its output token-minimally.
It exists because command output is the largest uncontrolled cost in an agent
session: a test run, a `git log`, a `kubectl get` can each spend thousands
of tokens restating things you do not need.
## What it guarantees
Read these once — they are why you can act on compressed output instead of
re-running the command verbatim to check.
- **The exit code is exact.** Never inferred from the text.
- **Error signal is never compressed away.** A failing command keeps its
diagnostics; compression targets repetition and noise, not failure.
- **Every elision is marked** — `…+N` (N more lines) or `×N` (repeated N
times). If you see no marker, nothing was dropped.
- **Any parse failure degrades to raw output.** Tiers fall back
aggressive → relaxed → verbatim. Output is never suppressed, so an unexpected
format costs you nothing.
## You do not need to type it
A PreToolUse hook rewrites covered commands automatically. **Write commands
naturally** — including inside pipelines and `&&` sequences. Do not prefix
`sctx` yourself on a covered command: it is not double-wrapped, but the
token is wasted and the command reads as though it needed help.
Wrapped today: `go`, `git`, `grep`/`rg`, `ls`/`find`/`tree`,
`cat`/`head`/`tail`, `diff`, `ps`, `du`, `df`,
`make`, `golangci-lint`, `gh`, `docker`, `kubectl`,
`helm`, `aws`/`gcloud`/`az`, `terraform`/`tofu`/`pulumi`,
`pytest`, `ruff`, `mypy`, `pip`/`uv`/`poetry`,
`npm`/`pnpm`/`yarn`, `cargo`, `dotnet`, `mvn`/`gradle`,
`composer`, `bundle`, `tsc`/`eslint`, `brew`,
`systemctl`/`journalctl`, `mongosh`, `rsync`, `jq`/`curl`,
`ssh` (delegates to the remote command's formatter).
**Coverage is per (program, SUBCOMMAND)**, which is why a command you expected to
be wrapped sometimes is not — a program is rewritten only for the subcommands it
has a formatter for. Plumbing verbs pass through raw (`git rev-parse`,
`go env`); their output is a line or two, so "no compression markers" does not
mean sctx is broken. Programs whose first argument is a path or host
(`grep`, `ls`, `cat`, `curl`, `ssh`) take no
subcommand and are always wrapped.
**Where the hook declines, and why it matters to you.** It leaves a command
alone when wrapping could change what you conclude:
- a downstream `grep`/`sed`/`awk`/`wc`/`jq` — filtering already-compressed
output would make something look ABSENT that is merely elided;
- file redirects (`> out.txt`), command substitution (`$(…)`), subshells.
`2>&1` is fine, and so are pure pagers (`| head`, `| tail`).
## When to type it yourself
**When you are about to run something NOT in the list above and its output will
be long.** `sctx <cmd>` still helps, whatever the program: JSON stdout is
compacted, and runs of repeated lines — the progress and status spam most tools
emit — collapse to one line plus a count. Nothing is summarised and nothing is
guessed at, so an unrecognised format costs you nothing.
`sctx -- <cmd>` forces verbatim passthrough when you genuinely need every
byte.
## The subcommand that changes what SynapCTX can answer
`sctx watch` streams the structural diff of the working tree — symbol names,
signatures, doc comments, never bodies — so `retrieve_context` answers about
the code being CHANGED rather than the last commit. Without it, uncommitted edits
are invisible to every SynapCTX tool, and a result will confidently describe the
committed version of a function just rewritten.
It is foreground and per-developer. Suggest it when a session has substantial
uncommitted work — but do not start a long-running foreground process on the
developer's behalf without asking.
`sctx doctor` shows CONFIGURATION — version, masked per-org API-key prefixes,
the default organization, and which agents here have been taught. It does not
print the covered-command list.
## Reporting
`sctx gain` shows tokens saved (`--project`, `--since 7d`,
`--format json`). `sctx gain --failures` lists commands that saved
nothing — the fastest way to find an output shape worth compressing.
<!-- 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.