Commands

stratless mirror     a free read of you and your AI, changes nothing (--share for a card)
stratless init       keep your history, and build your profile
stratless profile    see the model of you, free and instant
stratless update     read what is new, rebuild and load it
stratless stop       turn it off, and unload the profile
stratless status     its own state, and what it has cost
stratless mcp        serve the profile to any MCP client

mirror

$ stratless mirror

  You and your AI, measured

    you and your assistant    6,177 messages · 52 active days
    a median day              122 messages
    span                      2026-06-09 → 2026-07-30 · longest streak 52 days
    how you write             median 17 words · 8% four words or fewer · 42% questions
    what you keep typing      "go" 23× · "continue" 19× · "sure" 11×
    screenshots sent          210
    course corrections        2.44 / 100 messages
    tool declines             57
    friction days             47 of 52 active days
    not counted against you   69 permission stops · 34 system blocks
    busiest repo              stratless · across 6 repos · 52 branches
    tools it ran for you      29,101 calls · Bash 38% · Edit 27%
    work it handed off        636 agent runs · Explore 46% · general-purpose 43%
    skills it loaded          54 times · research 17% · artifact-design 13%
    profile captures          100% of your moments

The measured portrait of you, across every conversation, read straight from your live history. It is pure arithmetic: no model call, no tokens, no setup, and it changes nothing on your machine, so you can run it before you have ever run init. Bare npx stratless (no verb) runs it too. course corrections is how often you cut in to redirect your assistant, per hundred messages you send. what you keep typing is your most-repeated exact messages, quoted back; it exists for your terminal only and never appears on the share card. not counted against you lists the interrupts that are not your friction (permission stops and system blocks), shown so nothing is silently dropped from the count. work it handed off counts the times your assistant gave a piece of the job to another agent instead of doing it itself, and names the kinds it used most; a spawn whose kind the transcript never recorded still counts as a run but is never given a label, and the kinds stay in your terminal, off the share card. It appears only if you delegate at all. skills it loaded counts the packaged procedures your assistant pulled in for a job, and names the ones it used most. It is deliberately phrased from the assistant’s side: a skill enters the record the same way whether you typed its name or your assistant chose it, so the row never claims the reach was yours. Skill names stay in your terminal too. profile captures appears once you have built a profile, and shows how much of you the current build’s patterns cover.

Add --share for a clean, screenshot-ready card of the universal numbers, with any repo name, project name, and anything you ever typed left out, so it is safe to forward.

init

npx stratless init

The one interactive moment. It keeps your history, shows you a free read of yourself, quotes the full build honestly, and takes a single yes or no.

  1. It stops the reaper. Claude Code deletes your transcripts after 30 days, per file, so your history rots from the back even in a project you open every day. init sets cleanupPeriodDays to 3650 in ~/.claude/settings.json and copies every transcript it can still reach into ~/.stratless/archive/, out of the cleanup’s way. Whatever has already aged out is gone. This is the only part you cannot do later. Codex has no such timer, so nothing is switched off there; init still keeps its own copy of your rollouts.

    init does this for each assistant it finds on your machine, and only those. One you do not have is left alone entirely: no config file, no hook, nothing.

  2. It turns the after-session refresh on. From here, when a session ends, stratless reads what is new in the background and keeps your profile current. That is on the moment init finishes; stop is the one switch that turns it off.

  3. It reads you for free. Before anything costs a cent, init prints what it can already see from the history it just froze, computed with no model call: how much you talk to your assistant, how you write, how often you course-correct it.

  4. It quotes the build, then asks once. It shows an honest estimate (moments, dollars, minutes, all on your own claude) and itemizes the one-time engine download (~3MB runtime + ~34MB model), then asks Build your profile now? [y/N]. The default is no. Say yes and it fetches the engine in the foreground and builds now; say no and nothing is spent, nothing is downloaded, the free read stays, and the refresh keeps it current. The paid build never runs without that explicit yes on a real terminal.

To undo: set cleanupPeriodDays back to 30, run stratless stop, and delete ~/.stratless/archive/. That is everything it touched.

profile

stratless profile

profile is free to look at. It prints the last built profile instantly, at zero spend, under a header that carries the build’s own date and counts. It never builds and never loads: it shows you the current model of you, and it ends by saying honestly whether that profile is loaded into your assistant right now. Building and loading are update’s job.

There is nothing to configure and no flag to pass. If you have not built a profile yet, profile points you at stratless update.

update

stratless update            read what is new, rebuild and load the profile now
stratless update --weekly   auto-rebuild at most once a week (the default)
stratless update --daily    auto-rebuild at most once a day

Reads every session that is new since last time, places each new moment against the patterns already found in your own history, and rebuilds the profile. Placing is free and offline — it runs on the local model, so no matter how much you talked, sorting it costs nothing. Rewriting the file afterwards is free too in the steady state — every row’s wording is voiced once and re-stamped from a cache, so a rebuild only pays (one short call, cents) when your history earns a genuinely new row; a refresh with nothing new spends nothing at all. Run by hand in a terminal, it rebuilds now. Run by the after-session refresh, it rebuilds on a cadence: at most once a week by default, or once a day with --daily. update itself always rebuilds immediately, whatever the cadence is set to; the flags only change how often the background refresh acts on its own.

The moments collect every session for free. The cadence governs only how often stratless re-scores the pile and re-stamps the file, so a busy week costs the same as a quiet one.

The work runs in one background worker that update wakes and watches. Your terminal is a window onto it, not the engine. On a normal run you notice nothing: the same progress lines, the same closing summary. The difference is at the edges. Press Ctrl-C or close the terminal and the display detaches, but the work finishes anyway, and the profile lands a few minutes later. There is no daemon; the worker does its bounded job and exits. Sleep pauses it for free, and nothing already scored is ever lost.

Every run that spends closes with its receipt: tokens, the API-equivalent cost, and which models actually ran. status keeps the most recent one, so even the silent after-session refreshes stay accounted for.

A rebuild is a derivation, not an impression. The profile is written only from what your history supports, and if the writer invents a number that is not in the evidence, or returns anything that does not read like a profile, the build is refused and your old profile stays loaded. Nothing malformed ever loads.

mcp

stratless mcp

For another tool’s config file, not for typing. Every assistant loads its context from a different file in a different place, so reaching a new one has always meant teaching stratless that tool’s conventions. This is the way around that: stratless mcp speaks the Model Context Protocol over stdio, so any client that speaks MCP can read your profile without stratless knowing anything about its files. Point a client at it once:

{ "mcpServers": { "stratless": { "command": "stratless", "args": ["mcp"] } } }

It serves your profile two ways, because clients differ. At connect time it sends a short note saying what it carries and asking the assistant to read the profile before it does any real work. Then one read-only tool, who_am_i, returns the profile itself. The note is deliberately short: that channel is truncated by clients (measured: cut at exactly 2048 characters in one), and half an instruction is a wrong instruction, so the note tells the assistant what to call and the tool carries what to know.

It reads your HUMAN.md at the moment it is asked, so a rebuild reaches every connected client at once with nothing to re-install. There is one tool and it only reads — nothing here can edit your profile, propose a change to it, or write anything at all, because the profile is derived from your own history by arithmetic and there is nothing for an assistant to edit. If no profile has been built yet, it says so plainly and tells the assistant to treat you as unknown rather than guess.

Nothing leaves your machine: the server runs locally, talks over a pipe to a program already on your computer, and opens no network connection. It also does nothing until a client starts it.

stop

stratless stop

The off switch. If a rebuild is running right now, it is stopped within seconds: spending halts immediately, and nothing paid-for is wasted, since every moment already scored is banked and restarting later re-reads at most one small chunk. Then the after-session refresh is removed and the profile is unloaded from every assistant carrying it, your CLAUDE.md and your AGENTS.md alike. Your HUMAN.md file is left as is; delete it yourself if you want it gone. Being able to shut it up completely, mid-run, is half of why you can trust it.

status

$ stratless status

  stratless status

    after-session refresh   on
    auto-rebuild            weekly · set with `stratless update --daily|--weekly`
    profile loaded          Claude Code  yes  this build (2026-07-23 12:28 UTC) · ~/.stratless/HUMAN.claude-code.md
                            Codex        no   — not enough history yet

    recent builds
      2026-07-23 12:28 UTC   142 conv · 4,980 moments · 23 categories   (latest)
      2026-07-22 09:14 UTC   138 conv · 4,760 moments · 23 categories

    spend
      total           $0.28  ·  49k tokens  ·  3 calls  on your own claude
      by stage       naming $0.19 · writing $0.09

stratless’s own state: whether the refresh is on, how often it auto-rebuilds, whether your profile is actually loaded — and which build it is, by the file’s own # built stamp; a loaded profile that is older than the latest build gets flagged with the one command that fixes it — when it last built, and what it has spent of your borrowed claude. The loaded line names each assistant on your machine separately, because they are delivered to independently: Claude Code holds a pointer that stays correct through every rebuild, Codex holds a copy that has to be rewritten. If you run one assistant you see one row and are never told about a tool you do not use; if you run two, a profile sitting in only one of them says so, rather than one loaded tool answering for both. Tokens come first, because a subscription spends quota, not dollars; the dollar figure is the API-equivalent, labelled as exactly that and split by stage. The meter also confesses its blind spots: if a call ever runs on a fallback model, or a cache file on disk is damaged, status says so rather than showing a confident number. Every line is read locally; plain status is fully offline and spends nothing.

Add --check and it makes exactly one announced request to the npm registry to tell you whether a newer version exists: you ask, it checks, on screen. Beyond your own claude, the only other thing that ever touches the network is the one-time engine download at init (runtime + model, itemized), which you are asked about before it happens. See Privacy.

Global flags

stratless --version    print the installed version (short: -v)
stratless --help       the command list (also: -h, help)

Output through a pipe, or with NO_COLOR set, carries no color codes, so stratless status | grep loaded gives you clean text. An unknown flag or a stray argument stops with a loud error and a did-you-mean, never a silent misfire.

Read the source