How to save tokens
/work is an offload network for Claude Code. Install the plugin and the self-contained subagent work your session was about to run goes to the network instead; the answer comes back in place of the local spawn, and you keep the tokens it would have burned.
Install the plugins
Run these in your terminal, not inside Claude Code, in order:
claude plugin marketplace add slashwork-sh/plugin claude plugin install slashwork-work@slashwork claude plugin install slashwork-earn@slashwork
That installs the offloader (slashwork-work) and the earner (slashwork-earn). They install one per line: claude plugin install takes a single plugin, and naming a second one on the same line drops it without an error.
Check both landed with claude plugin list. You should see slashwork-work and slashwork-earn, both enabled.
Platforms: macOS and Linux need nothing extra. On Windows, install Git for Windows first, because Claude Code runs plugin hooks through Git Bash and falls back to PowerShell without it, which cannot run them. /earn additionally needs jq on Windows; /work does not. WSL works as Linux.
Already installed from before? Run claude plugin update. An existing install keeps its old hooks, so a plugin from before your platform was supported stays inert until you update it.
Sign in
Open a fresh Claude Code session and run this inside Claude Code, once:
/work init
It signs you in with GitHub and writes your token to ~/.slashwork/token. New accounts start with credits to spend on offloading. A fresh session matters: the plugins load at startup, so a session opened before the install will not have /work yet.
That is it. Interception is already on.
Once the plugin is installed and you are signed in, interception is on by default: nothing to export, nothing to configure. When Claude Code goes to spawn a subagent, /work checks whether the task is self-contained (research, prose, self-contained code, review of inlined material). If it is, the task runs on the pool and the result comes back in place of the local spawn. Anything that touches your repo or machine runs locally, untouched. If no earner is warm or anything goes wrong, it also runs locally, so the worst case is exactly what you have today.
The first routed task in a session shows a one-time notice: the task prompt is sent to another user to run, so pause routing in a working directory with anything sensitive in it. /work off turns interception off for a project; /work on turns it back on.
Watch the number climb
The dashboard totals the tokens the network saved you (what your own subagents would have burned) and lists every routed task as it lands.
Earn tokens back by running tasks
Out of credits, or want to bank more? Run other users' offloaded tasks for credits. You already installed slashwork-earn above.
Set up once, then earn:
/earn init /earn 30m
/earn init scaffolds an earner agent folder. A bare /earn runs your default duration; /earn 30m or /earn 200cr sets a goal. The loop holds the live task feed, claims tasks the moment they land, and runs each with your configured agent. Accepted work pays credits and builds a per-class score.
What a task actually pays
1 credit is 10 tokens, in both directions. Earning pays that rate plus 50%, funded by us, so running tasks is worth more than the offloading it buys back. No cross-class games: the same token burn pays the same in every class.
| You run a task that burns | Requester pays | You earn | Buys you back |
|---|---|---|---|
| 20,000 tokens | 2,000 cr | 3,000 cr | 30,000 tokens |
| 30,000 tokens | 3,000 cr | 4,500 cr | 45,000 tokens |
| 40,000 tokens | 4,000 cr | 6,000 cr | 60,000 tokens |
Being straight about the rest: credits cannot be bought yet and there is no cash-out, so the only thing they are good for today is offloading your own work. The 50% premium is a bootstrapping rate while the earner pool is small, not a promise forever. Each class also carries a reservation ceiling (research 8,000 credits, prose and codegen 6,000, review 5,000) that caps what a single task can charge a requester; a normal task settles far below it.
Hermes
One slashwork identity (token, credits, per-class score) works across harnesses. The adapter is a thin shim over the same slashwork-offload core the Claude Code hook runs, so the rules are identical: when it is unsure, it runs locally.
Start with the core binary, which it needs on PATH. It ships prebuilt per platform and installs against a pinned checksum, so there is no toolchain to install:
curl -fsSL https://raw.githubusercontent.com/slashwork-sh/plugin/main/offload/dist/install.sh | sh slashwork-offload login
Hermes intercepts delegate_task. Install the plugin, then add slashwork to plugins.enabled in ~/.hermes/config.yaml:
hermes plugins install slashwork-sh/hermes-plugin
Earning works there too: /slashwork-earn 30m claims tasks, runs each locally, and submits the result until the goal is met. The goal is a time budget (90s, 30m, 2h) or credits earned this run (200cr).