download
One command. It downloads the source, builds the agent, installs it to ~/.local/bin, and connects you to a dashboard — typically in under 5 minutes.
curl -fsSL https://lazytoken.org/install.sh | shWorks on macOS (Apple Silicon & Intel) and Linux (x86_64 & arm64). The script checks your prerequisites, offers to install Rust if it's missing, builds from source, and finishes with ltk enroll --cloud. Prefer to run it step by step? See Advanced / build from source.
… | sh -s -- --token <GITHUB_TOKEN>.
The one-line installer above does this for you. If you'd rather drive the build by hand — on macOS (Apple Silicon or Intel), Linux, or Windows — the agent is a standard Rust project and compiles in a few minutes.
# Prereq: Rust toolchain — https://rustup.rs
cargo build --release # inside the agent/ directory of the source tree
mkdir -p ~/.local/bin && cp target/release/ltk ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH" # add to your shell profile too
ltk --version # -> ltk 0.43.0Honest status: signed installers for every platform ship with the release pipeline; until then the agent builds from source in a few minutes.
Build from source today · signed & notarized installer next.
See instructions below · prebuilt + notarized builds are on the roadmap.
See instructions below · deb/rpm packaging scripts exist for enterprise fleets.
See instructions below · MSI packaging scripts exist; EV-signed installers are on the roadmap.
The agent is a standard Rust project (the toolchain is pinned in the repo). Any platform Rust supports:
# LazyToken is in private beta — source access is granted per request:
# email hello@lazytoken.org and we'll send you a repo invite.
# once you have access:
git clone https://github.com/YaakovTzedek/lazytoken.git
cd lazytoken/agent
cargo build --release
# binary lands at:
./target/release/ltk --version # -> ltk 0.43.0
# put it on your PATH, e.g.:
cp target/release/ltk ~/.local/bin/The one-line installer automates all of this. This manual walkthrough is here if you want to see (or control) every step — from an empty machine to a token-saving coding agent in ~10 minutes. Every command is real and tested.
step 1 / prerequisites
The agent builds with standard Rust (the exact version is pinned in the repo, rustup picks it automatically). You also need git.
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# then restart your terminal, and check:
cargo --versionstep 2 / request beta access
LazyToken is in private beta, so the source lives in a private GitHub repository. Email hello@lazytoken.org with your GitHub username — we'll send an invite (accept it from the email or at github.com/notifications).
step 3 / authenticate to GitHub
git clone worksA private repo can't be cloned anonymously — you must authenticate first. Easiest way is the GitHub CLI:
# macOS: brew install gh · see cli.github.com for other OSes
gh auth login # choose: GitHub.com → HTTPS → login with a browserPrefer not to install gh? Create a Personal Access Token (scope: repo) and use it as the password when git prompts.
step 4 / clone the source
git clone https://github.com/YaakovTzedek/lazytoken.git
cd lazytoken/agentIf this fails with Authentication failed or repository not found, your invite isn't accepted yet or step 3 didn't complete — that's the #1 install snag.
step 5 / build
One command; a few minutes on first build:
cargo build --releaseThe binary lands at target/release/ltk.
step 6 / put it on your PATH
mkdir -p ~/.local/bin
cp target/release/ltk ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH" # add this line to ~/.zshrc or ~/.bashrc too
ltk --version # -> ltk 0.43.0step 7 / hook into your coding agent
Wires LazyToken into your AI coding agent's command path — from now on its terminal commands are filtered automatically:
ltk init # Claude Code
ltk init --copilot # GitHub Copilot
ltk init --gemini # Gemini CLI
ltk init --codex # Codex CLIFor Cursor and other agents, run ltk init --show to see configuration options. --dry-run previews every change before writing.
step 8 / see it work
ltk git status # same info, a fraction of the tokens
ltk gain # your measured savings, per commandgit, tests, docker, and 100+ other commands are now filtered before they reach the model — and secrets in output are redacted locally.
step 9 / connect a dashboard (optional)
Enterprise — your org's server (this path is live today):
ltk enroll \
--server https://lt.company.internal \
--token ORG-XXXXXXXXXXXX
ltk statusFree (individual) — the hosted personal dashboard. Self-serve sign-up is rolling out; email hello@lazytoken.org for early access, then:
ltk enroll --cloudWithout enrollment, ltk filters locally and sends nothing anywhere.
git clone fails with Authentication failed / repository not found — the #1 snag: either your beta invite isn't accepted yet, or you skipped step 3 (gh auth login). Private repos can't be cloned anonymously.
· ltk: command not found — your PATH is missing ~/.local/bin; re-run the export in step 6 and add it to your shell profile.
· cargo: command not found — restart the terminal after installing rustup (step 1).
· Build errors about the Rust version — run rustup update; the repo pins its toolchain and rustup fetches it automatically.
Rolling out to dozens or hundreds of machines? Don't hand out tarballs — use the packaging + MDM scaffolding that ships with the product.
The repo's deploy/packaging/ tree builds native installers from a released binary:
LazyToken-<v>.msi), silent install with SERVERURL / ENROLLTOKEN properties.pkg with a post-install that enrolls as the console user.deb and .rpm (lazytoken-agent)Production signing (EV cert, notarization, GPG) is a release step documented in the packaging README — required before a regulated rollout.
Ready-made scripts and runbooks under deploy/mdm/, covered step-by-step in the Admin Guide:
.mst transform for parametersPre-seed the server URL and an org enrollment token, push through your MDM, and manage the fleet from the dashboard.
ltk update pulls from your own server's release channel and verifies sha256 + an Ed25519 signature before an atomic self-replace. You control the pace.
The 15-minute Quick Start takes you from zero to a live dashboard with demo data — Docker Compose or local Node, your choice.