Compaction, context pruning and memory selection with Jev: Claude Code and Codex plugins that judge each tool result before it reaches the model.
31 builds
tamara
@tamarajtran
found the perfect use case for @typesafeai Jev:
instant compaction
in 2026, why is compaction still a summarization prompt?
Jev can make it instant by scoring every tool call and dropping what’s irrelevant
A Pi extension: Jev picks the file excerpts, a local model writes the code.
MLMax Lv
11
Kun Chen
@kunchenguid
almost every day i hear people ask "when should i /compact my session"
there's no easy answer because it depends on how likely your future action will need detailed context in the existing window
but we have Jev now! introducing compact-adviser - an agent plugin you can use in claude and pi today to help determine whether you're likely at a task boundary that's safe to compact
https://github.com/kunchenguid/compact-adviser
i built a private eval set from 40 real sessions and manually labeled all the safe vs unsafe checkpoints to evaluate this, and hillclimbed the Jev prompt till it performed quite well
i also made it so that the classifier will
- optimize for precision (not triggering a compaction prematurely) when context window is small
- and gradually shift to optimize for recall (not missing an opportunity to compact) when context window fills up, because the cost of not compacting becomes higher, and at the end the agent will be forced to compact anyway
it supports a "hint" mode (just give you a hint and it's up to you to run /compact) vs "auto" mode which runs compaction whenever Jev says it's safe to do so
if you have Jev and want to put your compaction on autopilot, try this out and let me know how it goes! support for more harness is coming soon as well
Agent memory is usually just an append-only Markdown file that grows forever, and most frameworks load the whole thing into context on every single run. That has been bothering me for a while, but never quite enough to fix it for our agents. Jev feels like it might be a low effort patch to this, by simply scoring each memory against the prompt first, then load only the relevant bits for that specific request.
Jev Skill Suggestion for Claude Code is a smart idea.
Instead of loading every skill into context, Jev decides which one is actually relevant and injects only that.
My takeaway: better context hygiene, less clutter, and potentially more efficient agent workflows.
@typesafeai @vercel
Jev has some invisible use cases that won’t be clickbaity but hella useful :
- auto performance checks on your shipped websites
- personal tools like using it for super quick chat compaction
- user feedback prioritisation against most relevant data in your company
- lots and lots of data sorting - quickly
- pairing it with codex / claude to optimise decision making while you code with your agents etc
This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run!
Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮
Ask your claude to install it and be amazed
Use this prompt
```
Install, and configure :
https://github.com/tamaratran/fast-jev-compaction
```
Instant Claude Code compaction is my favorite use of Jev so far
For people going to complain about me letting my context get so long, this was a server redeploy task because Oracle terminated my free VPS with no explanation so it had a lot of moving pieces
Test what your AI should remember, with Jev deciding admission.
CCairn-ink
CyrilXBT
@cyrilXBT
JEV IS INSANE
your coding agents forget everything the second the session ends.
Every fix. Every dead end you already hit. Every "no, not like that."
Gone. Tomorrow you teach it all over again.
Someone just open sourced the fix, and it runs on Jev.
It's called Beacon, by @asymptotelabs.
It pulls in your session history from Claude Code, Codex, Cursor, OpenCode and 20+ other agent tools and turns it into one shared memory.
But storing everything isn't the hard part.
Most agent runs are GARBAGE to learn from.
Failed commands.
Wrong turns.
One off hacks you'd never want repeated.
Save all of that and your agent just gets confidently worse.
So Beacon keeps the full history, and Jev decides what actually earns a spot in memory.
Promote it.
Send it for review.
Or throw it away.
That's a decision you need on thousands of sessions, which is exactly why it has to be cheap.
The runs that survive get turned into reusable skills.
So something Cursor figured out on Monday shows up in your Claude Code session on Tuesday.
Your agents stop starting from zero.
Every good run makes the next one smarter.
Repo: http://github.com/Asymptote-Labs/agent-beacon
Star it and save this.
follow @cyrilXBT
Explorando qué se puede hacer con Jev y Laya, que (los de moda), me pregunté si podrían ayudar a un agente de soporte a preparar el contexto mientras el usuario escribe su mensaje. El contexto es clave para un LLM, así que armé una startup ficticia con 7 documentos. 🧵
tab-jev: jev-like model + tabular foundation model = an in-context learner for your text & tabular data.
https://github.com/edamame-labs/tab-jev
Many real industry datasets are a mix of tabular and text data:
- Tabular foundation models like TabPFN learn from a few hundred labeled rows in context, with no training. But they can't read text.
- Jev-style models read text and answer typed questions with scores. But they can't digest tabular data well.
Experiment results on kaggle problem "Kickstarter: will the project get funded?" is shared in the repo.
Missing a flight at JFK is a productivity booster...