u/Clear_Sights

Repo: https://github.com/Clear-Sights/Lever

The premise: an LLM is good at exactly one thing, reasoning. Almost everything else an agent spends tokens on is transport. Fetching a page and pouring 20,000 characters into context is transport. Re-reading a file it wrote ten minutes ago is transport. Quoting tool output back is transport. Transport doesn't need a model. It needs a content-addressed store and some pure functions.

So Lever swaps the default paths for deterministic ones, through ordinary Claude Code hooks:

A fetch or a big command output lands in a local content-addressed store first, at wire speed, before any of it becomes tokens. Context receives a bounded window plus the artifact's address and the exact one-line command that retrieves any slice of the rest. The model reads what it needs instead of everything it was handed. On my build sessions this replaced 47% of the tool-result bytes that would have entered context, and pushed the auto-compact point back by about an hour.

The same store makes other things free. A repeated prompt gets answered with the address of the prior reply. Subagent results become addressable artifacts the moment they exist. When the model cites an address in its reply, a display hook renders the actual bytes on your screen, so it can answer with a pointer instead of regenerating content.

Redirects exist too, but they're the boundary case, not the point: when the default path is provably identical to a free deterministic one, the hook says so. Type a raw grep into Bash and the response is the equivalent Grep tool call, already translated. Attempt a Write that's byte-identical to what's on disk and it comes back "this is a no-op, skip it." Exact predicates only. I tried a fuzzy similarity threshold early, watched it score 49 identical lines out of 50 at 0.78, and deleted the whole approach.

Caveats I'd rather list myself. The 47% comes from my own sessions; the repo's dev side has a replay tool that computes the same numbers for any transcript, so check it against yours before believing me. Hooks cost about 60ms per call since Python startup dominates, and a Go dispatcher is planned. Two features I expected to matter measured near zero on my corpus, so they don't exist, and the repo records why instead of shipping them.

Apache 2.0. Install is enabling the plugin.

(Detent is the new name, same link, it redirects)

A few months of heavy Claude Code use taught me to stop trusting its summaries. "All tests pass" — with a || true quietly appended to the failing command. "Done, created the file" — and the file wasn't on disk. "Verified the cert" — after it set verify=False. None of these are exotic. If you run an agent on real code, you've shipped at least one without noticing.

The reflex is to verify harder — re-run the suite, diff the output, check the cert. That's a losing game: to know whether the tests really passed you need a verifier about as capable as the work itself, and now you have two things that can be wrong instead of one. The move that works is the opposite: you don't check whether the tests pass — you check whether the agent ran them, and what that run recorded. A green claim sitting over a recorded failure, or over no test run at all, is caught without anything ever executing your code.

And it generalizes past tests. It said it cited a paper — is that paper in the file it declared? It said it fetched a URL — did any earlier tool actually open it? You never ask "is this true of the world?" — only "does the claim match what the agent actually did this session?" Those are different problems: the first has to understand your code, the second is a lookup against a record. A claim is only as real as the deed behind it. Realness isn't something you audit after the fact — it's whether the word was kept. Wet is what water is.

That reframing is also the only reason such a checker can run at zero false positives — and the zero-FP part, not the catching, is the hard half. Anything that reasons about the world is eventually wrong about the world. A check that only compares "you said X" against "the record shows not-X" has nothing to be wrong about. The grind is the other direction: not crying wolf. "I'll add rate-limiting to auth.py" is a real promise. "settings.json keys" is a mention. "Option A: add a cache layer" is a proposal you're weighing, not a commitment. The same words inside a code fence are a demo. Telling those four apart — flag the broken promise, stay silent on the rest — is most of the work, and it's the part a regex and good intentions won't get you.

Here's the part you can use today, tool or no tool. It's a short list to grep your agent's recent diffs and turn summaries for:

• || true, set +e, or 2>/dev/null on a test, build, or lint command
• a check body quietly reduced to return True or pass
• verify=False, CERT_NONE, or a JWT none algorithm
• a "done / created X" with nothing new on disk
• an "I ran it" in a turn where no command actually ran
• "all tests pass" while pytest's own lastfailed still names a failure

Those are the shapes an agent reaches for when the task is hard and a green checkmark is cheaper than the work.

I packaged the idea as a Claude Code plugin — Makoto. It runs on the agent's own tool calls; when a claim isn't backed by the record it blocks the call (exit 2, which Claude Code retries) and hands back a one-line correction. About two dozen checks. Every one blocks at a measured zero false positives over a 1,335-session corpus or it gets cut — there's no "warning" tier on purpose, because a check that sees a violation and waves it through is just another empty word. The docs keep an honest ledger of where it still falls short, including that it doesn't yet guard its own comparators. I'd rather say that than overclaim coverage on a tool whose whole job is catching overclaims.

Install: /plugin install https://github.com/Clear-Sights/Makoto (Apache-2.0, Python). It's early. If you try it, the most useful thing you can send back is a false positive — the entire design rests on there being none.

https://github.com/Clear-Sights/Makoto