DEV Community: Avinash Jetwani

Can a local model replace Jev in my Claude Code memory tool? I tested two

Avinash Jetwani — Tue, 20 Oct 2026 12:50:00 +0000

Someone on GitHub asked if jevmem could run fully local.

Fair question. Today jevmem needs a paid TypeSafe API key: it sends each message, with common secrets removed, to TypeSafe's Jev API to decide what's worth saving.

Ollaya runs open decision models on your own machine, and it answers in the same format as Jev's API. So I pointed jevmem at it.

It connected with no code change: one URL, any key, and the model's name in the config.

Then I ran the same tests I use for Jev.

Setup

2 Oct 2026. M4 Mac with 16 GB, Ollaya 0.9.0. One run each, next to a Jev run the same afternoon.

Deciding what to save (66 held-out turns)

	Save/skip right	Save + kind right	Median per turn
Jev	65/66	63/66	0.23 s
winnow:e4b (8 GB)	60/66	57/66	28.5 s
laya:typed-decisions (852 MB)	19/66	19/66	13.6 s

Both local models needed the client timeout raised from 10 s to 180 s.

Recall and the guard (laya only)

Recall: no answer came back within jevmem's 1-second budget, so every prompt fell back to word matching: 48 of 78 wanted lines, against Jev's 73. Its 1,024-token context can't hold an 18-line memory file anyway.
Guard: fast enough (158 ms median), but it caught 43 of 68 rule breaks with 13 false asks. Jev caught 66 with 3.

What it means

On a laptop, not yet, so jevmem 0.7.6 still uses Jev. The accurate model is over 100× slower. The fast one is wrong too often.

But 60 of 66 is close. And on JevBench, larger open models score near Jev when they run on servers. So this may change with better hardware, or the next models.

If you have an NVIDIA GPU and want to try, scripts/local-model-ollaya.sh in the repo runs each test against a local server. I'd love to see your numbers.

Repo: https://github.com/Avinash-jetwani/jevmem · Results: https://avinash-jetwani.github.io/jevmem/results/#can-a-local-model-do-jevs-job · JevBench: benchmarkheaven.com/jev-models

Written with help from Claude. The numbers are from my own test sets, run once each, and the results files are in the repo.

How I built a scam-link checker on Jev

Avinash Jetwani — Fri, 16 Oct 2026 22:02:34 +0000

Scam links are built to look normal: a parcel fee, a tax refund, a short link from a friend. You can't tell where a link goes by reading it. So I built Peekray, a free Chrome extension and phone page that shows where a link really goes before you click, with one answer: Safe, Check first or Scam.

Lists first, then Jev. Peekray follows short links and redirects on its server, up to four hops. Then it looks the final address up in three public threat lists: OpenPhish, PhishTank and URLhaus. Lists are fast and certain, but they only know scams someone has already reported. A scam site registered this morning isn't on any of them.

That gap is where Jev, TypeSafe AI's decision model, comes in. I didn't want a chatbot writing a paragraph about each link. I wanted a decision my code could act on, fast enough to show while your pointer is still on the link.

One call, four questions. For each link no list knows, Peekray makes one Jev call. The state is the link, where it really lands, the redirect chain, how many days ago the domain was registered, and about 30 yes/no signals, such as a lookalike brand name, payment words or a free website host. Jev answers four questions together:

Is this likely phishing or a scam? (yes/no)
Does the visible link text name a different site from the real address? (yes/no)
Is it spammy or misleading? (yes/no)
Overall: Safe, Suspicious or Scam? (a choice)

Each answer comes back with a probability, so Peekray can be strict where it matters.

Guardrails. Text from the page is treated as untrusted: it is shortened, email addresses and long numbers are removed, and a page title that tries to talk to the checker is dropped. Peekray's own rules can make Jev's answer more careful, never less. If a call hangs, a second one starts after 2.5 seconds and the first answer wins. If Jev is unavailable, a rule-based check answers instead of failing. Answers are cached for 10 minutes.

Speed. On a fake parcel-fee link, Jev decided in 0.19 seconds. Across 40 live checks the median was 0.17 seconds, so most checks finish in under a second from hover to tag.

What I just tuned. Obvious fake payment and sign-in pages used to come back Suspicious rather than Scam. Now strong signals, such as a lookalike brand on a payment or login page, take them straight to Scam.

Privacy. Only the link you hover, focus or click is checked, with its text and the page title. Never passwords, forms or cookies. No account.

Try it without installing at peekray.com/share, or get it for Chrome: chromewebstore.google.com/detail/peekray/bmiolholodlhbdfecjihpkencpccknjp. I'd love to hear about any link it gets wrong.

I made Claude Code check its commands against my project's rules

Avinash Jetwani — Thu, 15 Oct 2026 12:50:00 +0000

Some of my project's rules live in old chats.

"Never commit .env files." "Ask before pushing a tag." "Don't edit the generated client by hand."

Claude can only follow a rule that's in front of it when it acts. So in jevmem 0.6, I added the guard.

How it works

Claude wants to run a command or edit a file (Bash, Edit or Write).
Plain code looks for saved rules the call might touch. Most calls match nothing and go straight through.
Only those candidates go to Jev, which judges whether the call may break the rule.
If it might, Claude Code asks you first. You decide.

Since 0.7.0 (9 Oct), you can also mark your own rules as trusted with jevmem trust. In block mode, the guard can then stop a call that breaks a trusted rule, instead of asking.

The test

I wrote a held-out set before fixing anything: 274 tool calls in 5 new projects, 68 of them breaking a saved rule.

The first build caught 50 of 68. After the fixes, 66 of 68, with 3–4 false asks in the 206 fine calls.

In my own repo, over 65 real calls, it asked 3 times. Two were right. One wasn't.

What it misses

It matches on the words a rule and a call share, so it can miss:

a rule that shares no words with the command
calls like git tag -d or npm version, which share one word with a rule
a slow answer: if Jev is late on a weak match, the call goes through. On a strong match, it asks.

It's a backstop, not a sandbox.

What to know

It needs a paid TypeSafe API key: the check runs on TypeSafe's Jev model, so the call and the matching rule go to their API. The repo's privacy notes say exactly what's sent.
No telemetry.
The guard runs in Claude Code. jevmem also saves from Cursor chats since 0.7.4, but it doesn't check Cursor's commands yet.
The numbers come from my own test sets, run once each.

Try it

Claude app → Plugins → Discover → jevmem → Add
npm install -g jevmem
jevmem setup in your project folder (it asks for your TypeSafe key and turns jevmem on there)

The guard runs in "ask" mode by default.

Repo: https://github.com/Avinash-jetwani/jevmem · How the guard works: https://avinash-jetwani.github.io/jevmem/guard/

Written with help from Claude. The numbers are from my own test sets, run once each, and the results files are in the repo.

I tested whether Claude Code follows decisions from earlier chats

Avinash Jetwani — Mon, 05 Oct 2026 14:02:38 +0000

I got tired of re-explaining my project to Claude Code every session.

We'd decide something in one chat. "We use Postgres." "Don't touch the public API." "That migration approach failed, and here's why." A few sessions later, I'd be typing it again.

CLAUDE.md fixes this if you keep it updated. I didn't.

So I built jevmem.

What it does

You decide something in a Claude Code chat.
After each message, Jev (TypeSafe AI's decision model) checks if it's worth keeping: a decision, a rule, a bug, an approach that failed.
If it is, jevmem writes one line to JEVMEM.md in your repo.
Next session, the lines that matter for your prompt go back to Claude.
Change your mind, and the old line is crossed out.

Your team gets the same file through git.

Does it work? I measured it.

24 tasks in 3 small projects, 3 runs each. Real Claude Code sessions with claude-sonnet-5. Each task has a right answer that depends on a project decision saved earlier.

Three setups: no project memory, jevmem, and the same lines written by hand into CLAUDE.md.

	No memory	jevmem	CLAUDE.md
Followed the project's decision	28/72	66/72	67/72
Tried a change the project forbids	10/18	0/18	not run
Repeated an approach that had already failed	3/15	0/15	0/15

So jevmem is about as good as a hand-written CLAUDE.md. The difference is that you don't write it.

Where CLAUDE.md won: a convention nothing in the prompt points to, a rule for every user-facing string. CLAUDE.md got it 3 of 3 times, jevmem 0 of 3. Rules every task must follow still belong in CLAUDE.md.

What to know

It needs a TypeSafe API key.
Message text goes to TypeSafe to be scored. Common secrets are scrubbed first. No telemetry.
Automatic in Claude Code. Codex and Cursor use the same file over MCP.
These are my tasks and my projects. The scripts and results are in the repo, so you can check them.

Try it

Claude app → Plugins → Discover → jevmem → Add
npm i -g jevmem
jevmem key, then jevmem enable in your project

Open source, MIT. Built on TypeSafe AI's Jev.

Repo: https://github.com/Avinash-jetwani/jevmem · Full results: https://avinash-jetwani.github.io/jevmem/results/

I'd love to hear where it saves the wrong thing.

Written with help from Claude. The numbers are from my own test runs, and the results files are in the repo.

I built a Polymarket idea tester that will kill your strategy (paper-only, no wallet)

Avinash Jetwani — Fri, 25 Sep 2026 13:51:41 +0000

I keep seeing the same ask: how do I test a Polymarket idea before I put money on it?

Most answers point at one of three things. A live simulator with fake cash on live odds. A Python backtest notebook. Or a dashboard that never quite says stop.

I wanted a fourth option: type the idea in English, run it on resolved history, and get a verdict I could read without translating a log. Keep. Kill. No edge. Inconclusive.

That product is OddSage — https://oddsage.com

What it is
OddSage is paper-only Polymarket research. No live trading. No wallet. No copy-trade execution.

Two ways in:

Paste a Polymarket URL. You get a Market Dossier — a research page for that market, not an order ticket.
Type the idea in English. The builder drafts a strategy. You read the draft. Save and run.
The loop is: English idea → draft → Save & run → verdict.

What the verdicts mean
Keep: the paper test left something worth holding. Still paper. Not a live order.

Kill: it did not survive.

No edge: it ran and still looked like noise.

Inconclusive: not enough evidence. That is a stop, not a soft keep.

A tool that only ever says “interesting” is a mood board. I wanted one that would kill an idea.

What it is not
It is not a live virtual wallet. If you want to practice clicking on live odds with play money, use a simulator. That is a different job.

It is not a Python SDK. If your edge already lives in a notebook with L2 replay, keep that workflow. OddSage is for people who have a sentence and want a keep/kill without opening a repo.

It will not copy another trader onto your book. It will not place the trade if the verdict is keep.

A public kill
I am not going to invent a win rate for a launch post. Here is a finished public paper-test that did not get a pass:

https://oddsage.com/strategy/259bc179-04dc-4e6d-816d-59d8f3cb52cc

If a tester never shows a kill, it is selling hope.

Why I am posting this on DEV.to
Because the SERP for “polymarket strategy tester” and “test polymarket strategy” is full of Python tutorials and sim waitlists, and the category still needs a clear paper-only option that admits failure.

Tagline I keep using: Test your Polymarket idea before you risk real money.

Product pages if you want the job by name:

https://oddsage.com/polymarket-strategy-tester
https://oddsage.com/test-polymarket-strategy
https://oddsage.com/polymarket-paper-trading

I’m Avinash Jetwani. On X: @jetwaniavinash

If it dies, it dies on paper.