Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Everyone is keeping quiet about this for now, but it's something everyone will be using soon Claude + Jev = Second Brain Diogo Almeida, who developed the Jev system, shared a simple thought "The point of Jev isn't to make the model smarter in a conversational sense, but to...

10,656 Aufrufe • vor 6 Tagen •via X (Twitter)

39 Kommentare

Profilbild von Hussain Hashim | Building SundayBack
Hussain Hashim | Building SundayBackvor 6 Tagen

@Bober_smart defining clear inputs for Jev can make it more effective. I learned this when I hit a wall with my own AI project.

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

That is precisely how he solves the global problem

Profilbild von Hussain Hashim | Building SundayBack
Hussain Hashim | Building SundayBackvor 6 Tagen

@Bober_smart haha, right? curious, what part stood out to you most?

Profilbild von BlockFrontier
BlockFrontiervor 6 Tagen

I like the separation of responsibilities: deterministic rules decide what matters, while the model focuses on reasoning and communication. That could make agent memory much more reliable.

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, that is what makes this system special

Profilbild von Gipp 🦅
Gipp 🦅vor 6 Tagen

bidirectional links saved my chaotic vault last month

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yeah, man

Profilbild von shmidt
shmidtvor 6 Tagen

obsidian past - jev now

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

You should start using this as soon as possible

Profilbild von hammertime
hammertimevor 6 Tagen

the best second brain might just be one that knows what to forget

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

By the way, yes, that's a great idea

Profilbild von EugBass
EugBassvor 6 Tagen

Jev is a real treasure for the second brain

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, the second bridge looks completely different now

Profilbild von Nitesh
Niteshvor 6 Tagen

this could make AI memory much more useful

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, that is a more rational use

Profilbild von MJ | indie iOS dev
MJ | indie iOS devvor 6 Tagen

Retrieval is the easy half. What breaks my notes setup is stale entries piling up until the model trusts old decisions. Does Jev have any way to prune or expire what it wrote?

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Ohh yes

Profilbild von Yuvelir
Yuvelirvor 6 Tagen

This visualization slaps. Deterministic second brain is exactly what most agents are missing.

Profilbild von Zentrix⌚️
Zentrix⌚️vor 6 Tagen

That separation could make agent workflows far more reliable

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, reliability is one of the main criteria

Profilbild von Ridark
Ridarkvor 6 Tagen

The way this terminal looks makes work feel good

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, this is a clear demonstration

Profilbild von EagleVision
EagleVisionvor 6 Tagen

but it still feels like a very complicated system to me

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

You only need to figure it out once, and everything will become clear to you

Profilbild von Dekos
Dekosvor 6 Tagen

Soon everyone will start talking about it

Profilbild von Bober_smart
Bober_smartvor 6 Tagen

Yes, you need to be one of the first

Profilbild von boan
boanvor 6 Tagen

love the save vs skip approach

Profilbild von rondd
ronddvor 6 Tagen

@flamurbahtijari

Profilbild von maximus
maximusvor 6 Tagen

The division of labor decides

Profilbild von David Arias, CFA
David Arias, CFAvor 6 Tagen

I've been personally taking some time to develop Jev systems for financial systems and I liked your idea, especially separating decision-making from generation. I’m curious where the determinism actually begins though. In finance, for example, an agent might read “management expects margins to decline 50 bps next quarter.” Whether that’s worth keeping depends heavily on the task and context, and later guidance could partially contradict it. Save/skip can be deterministic once the signals and thresholds are defined, but relevance and contradiction still require semantic judgment somewhere upstream. Would be interesting to see exactly what the 98.5% is measuring. Thanks!!

Profilbild von sof j.
sof j.vor 6 Tagen

So real

Profilbild von Samuel Hu
Samuel Huvor 6 Tagen

second brain only worked for me when jev had a hard gate before write. otherwise it just filled notes with confident wrong summaries

Profilbild von vvtentt
vvtenttvor 6 Tagen

we are similar😅

Profilbild von Crio Songo
Crio Songovor 6 Tagen

This design solves LLM hallucination perfectly, privacy local storage is also a plus.

Profilbild von tenzo
tenzovor 6 Tagen

this is a much smarter way to build memory

Profilbild von magsimich
magsimichvor 6 Tagen

Second brain setups are getting good

Profilbild von Brjan | AI Builder
Brjan | AI Buildervor 6 Tagen

it's a bold claim, but people often overhype new AI integrations without real use cases

Profilbild von La IA Actualidad by Daniel
La IA Actualidad by Danielvor 6 Tagen

Interesante separar la decisión de qué conservar del trabajo de redacción del modelo. Es una distinción parecida a la que estamos viendo en memoria para agentes:

Profilbild von Macro Bombastic
Macro Bombasticvor 6 Tagen

deterministic decisions plus llm just writing is honestly the right split tbh

Ähnliche Videos

Jev has been blowing up lately. If you've got the Jev API but don't know how to play around with it yet, you can just copy this checklist. 1. jev-ultrafast A high-speed browser Agent built with Browser Use. Jev only judges "what to do, which element to click" at each step, and only calls the small model when typing is needed. Searching for a flight on Google Flights takes about 7 seconds. 2. fast-jev-compaction Context compression for Claude Code. Before each tool call, have Jev judge if there's anything still useful; delete the useless stuff, and keep the original text without rewriting it. 3. json-render Vercel Labs' generative UI framework. In experiments, Jev doesn't write JSON token by token; it just handles selecting components, properties, and layouts. 4. typesafe-mcp Best for people who just got the API. Plug Jev into Claude Code, Claude Desktop, Codex, and Pi, and do Choice / Score / Noul anytime. 5. jev-mcp Ready-made Agent judgment toolkit: fact-checking, content screening, semantic ranking, classification, and information extraction. 6. SemDecide Turn Jev into a command-line tool. Directly classify, score, and filter in the Shell—great for hooking up to crawlers, CI, and data pipelines. 7. jev-codex-router First have Jev judge how hard this round of programming tasks is, then decide the model tier, reasoning depth, and speed mode. 8. Winnow Context garbage collection for Claude Code. When Read / Bash / Grep spits out a ton of stuff, Jev first judges which parts are really relevant to the current task. 9. jev-review Before code review, run it through Jev first to pick out high-risk changes, then hand them off to a pricier big model or a human. Comes with a local dashboard. 10. Blink Use Jev as a code repository navigator. At each directory level, judge which files are most relevant to the current issue, then keep digging down. Copy these complete Jev blueprints - then read full Jev setup below ↓ ↓

rody

202,492 Aufrufe • vor 12 Tagen

this is f*cking gold 20 GitHub repos with 500K+ combined stars that will level up your JEV workflow AGENTS > jev-ultrafast: Jev picks every click and DOM target, a small LLM only types > hermes-jev-skills: routing, memory, compaction and skill picks in one pack > typesafe-computer-use: OCR reads your Mac screen, Jev picks the next click MEMORY > fast-jev-compaction: scores every tool call keep, truncate or drop instead of summarizing > jevmem: project memory for Claude Code, Cursor and Codex, updated every turn > jev-second-brain: your Obsidian vault, Jev judges which notes duplicate, revise or contradict SAFETY > jev-guard: a gate before every tool call, Jev scores the risk, you set allow, ask or deny TOOLS > skills: the official TypeSafe skill for Claude Code and Codex > system-one-adapter-python: dry-run your questions on an ordinary LLM before you burn a Jev key > jev-mcp: claim checks, screening and ranking as MCP tools > typesafe-mcp: plug Jev into any MCP client > json-render: Vercel's generative UI, where Jev picks the components OPEN MODELS > SemIf-OpenJev: semantic ifs from frozen open models kev: Jev-like models on Qwen that run on your MacBook > laya-mlx: the Laya decision engine on Apple silicon > clm: an open System One model with Choice, Noul and Score > jevlike: train your own Jev-like model TRADING > jev-trader: one buy or sell decision per Monad block START HERE > awesome-jev: the biggest map of everything built on Jev > awesome-jev-by-typesafe: use cases, patterns and starter code bookmark it before your next build

NO1ennn

18,445 Aufrufe • vor 5 Tagen

Top 9 agentic use cases for Jev: (bookmark this) Jev handles semantic decisions that ordinary code cannot express reliably. It returns typed answers and probabilities, while code continues to cover the workflow. Here are 9 practical use cases for Jev: 1. Browser next action > Convert the current DOM state into a bounded action such as click, type, or stop. Code executes only valid operation-target pairs. There are already several open-source Jev web agents. 2. Context compaction > Decide which events from a long agent trace should remain. The selected text stays verbatim instead of being replaced with a generated summary. 3. Skill and context loading > Compare the current user turn against the available skills. Load only the instructions needed for that turn instead of filling the context window with every skill. 4. Typed tool-call compilation > Map a natural-language request to a function and fill its typed arguments. Each argument is evaluated separately before code allows execution. 5. Citation verification > Check whether a quoted passage exists and whether the surrounding evidence supports the claim. The output can be supported, unsupported, or contradicted. 6. Extraction verification > Run a cheap extractor first, then use Jev to verify questionable fields. Clean records stay on the fast path while uncertain ones reach a reasoning model. 7. Agent trace evaluation > Turn raw trajectories into queryable labels such as progress and repetition. This avoids asking another LLM to write a full review of every run. 8. Semantic regression tests > Replay a trace suite against a new agent build. Semantic checks can then pass or block prompt, model, tool, and policy changes in CI. 9. Jevgrep code search > Search a codebase by what the code does rather than its exact words. Jev scores candidate snippets and returns the most relevant code first. If you want to see the final pattern in practice, it is already implemented in the Beacon open-source project. It captures full sessions across Claude Code, Codex, Cursor, OpenCode, and 20+ agent harnesses, and then Jev identifies which workflows and corrections are worth learning from, so that a lesson discovered by one agent can become available to the others. GitHub repo: If you want to dive deeper, check out the full guide on Jev below ↓

rody

46,828 Aufrufe • vor 5 Tagen

Jev is cool. So is it's OSS companion, Laya. The Latest Cool Thing In AI™ tends to get a lot of hype, sometimes without everyone even understanding it. So... what is this thing? Jev is an AI model that consumes input and produces output VERY differently than chat, claude, grok. The input is two things: 1) Text state to assess. Email, html, code, whatever. 2) A set of questions which will be asked about the attached state. The canonical example from TypeSafe's docs is to identify the urgency of a support ticket. We pass the model the customer text + a single noul question "is this urgent?". Jev returns a full set of JSON. This JSON is not generated with token-by-token autoregression. Jev is not trained to produce sequences of text tokens, rather to answer questions, and guarantees well-formed responses. In the example below, we see it produces a 0.99 probability (on a 0-1.0 scale) that the answer is "yes." Jev supports exactly three types of questions (seconds example in video): a) Noul: 0–1 probability that the answer to a yes/no question is "yes." b) Choice: Ask question with pre-defined set of answers. Jev chooses the best and assigns probabilities to each. c) Score: Ask question with pre-defined scale of answers. Jev produces a position on the scale. Jev computes answers for all questions in parallel, making responses super fast even for many questions in a single request. This might seem like a narrow set of capabilities, but in the right contexts leads to incredible potential. It also makes for a useful API / primitive for programming, since the outputs are... *ahem*... type-safe and predictable in structure. Jev is not going to replace LLMs for writing your code, auto-generating your docs, or being at the core of an agent harness. But Jev IS incredibly cool, and will be used to build a lot of amazing tech. Hope this helps.

Ben Dicken

40,810 Aufrufe • vor 14 Tagen

JEV + OPUS 5.5 IS INSANE FOR BUILDING A COMPANY BRAIN I pulled the whole architecture out of the TypeSafe and Anthropic docs and packed it into a 14-page PDF the 10 steps: 1. meet the pair > Opus 5.5 thinks, Jev decides, your code holds the branch 2. stop asking a text generator for a yes or no > Jev returns a typed answer with a calibrated probability in 0.44s for $0.00035 3. ask everything at once > Choice, Score and Noul run in parallel, so the fourth question costs almost nothing 4. branch on the number > 0.999 goes straight into the if statement. ~99% of turns end right here 5. stop routing blind > Opus 5.5 to Sonnet and back costs 5.84 against 3.32 for staying on 5.5 6. keep one context warm > cache reads at $0.20 per Mtok are 20x cheaper than a fresh load 7. escalate the hard part > the toughest 1% goes to Opus 5.5 with 1M context and 66.4% on Terminal-Bench 4.0 8. score every chunk on every query > keep whole, summarize or drop. the context gets rebuilt each turn 9. gate the actual command > every bash call gets classified before it runs, inside your own code 10. judge 100% of runs > $3.50 a day for 10,000 traces, and it matched the human label on all 500 decisions the result: a while loop that paid a frontier model for every tiny call turns into a brain that spends a fraction of a cent to notice and pays properly only when it has to think the person who brings this into their team walks into the budget meeting with the AI bill cut and the output up the PDF maps the company brain. the loop side of it - how Jev takes a Claude bill from $765 to $3 a month - is in the article below ↓

Mr. Buzzoni

85,590 Aufrufe • vor 6 Tagen

Another insane Jev use case! Jev makes it incredibly cheap to evaluate and classify agent runs at scale. And finally, someone open-sourced a self-improving memory layer that can put that capability to work across agent harnesses. It turns your agent sessions into a compounding knowledge layer, where every successful run can make future agents smarter across: - Codex - Claude Code - Cursor - OpenCode and 20+ more Beacon by Asymptote Labs continuously builds a shared history across your agent harnesses and uses Jev to identify the runs worth learning from. It then turns the best workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐) Most agent runs are messy. They contain exploration, failed commands, dead ends, and one-off fixes that should never become permanent memory. So Beacon preserves the full session history, while Jev helps decide what should be promoted, reviewed, or discarded. The recording below shows this in action. Beacon found 579 sessions across 5 coding-agent harnesses and normalized them into one consistent history. From there, Jev surfaces the lessons worth keeping and makes them available across your agent stack. - A pattern learned in Cursor can carry into OpenCode. - A lesson from Claude Code can improve the next Codex run. Every successful run adds to the shared knowledge layer, making future agents smarter. If you want to dive deeper into Jev, I also wrote a breakdown of how it works. The article is quoted below.

Akshay 🚀

119,118 Aufrufe • vor 10 Tagen

Jev has been exploding in popularity recently. If you already have access to the Jev API but aren't sure how to start experimenting with it, just copy this checklist: 1. jev-ultrafast Browser Use's fastest agent. Jev decides the next action and which element to click, and a language model is only called when text has to be typed. 2. typesafe-mario Jev plays Super Mario Bros. from structured emulator state, choosing every action from features pulled out of the game. 3. jev-plays-pokemon Reads Pokémon Red's game state as text, answers typed questions each turn, and lets plain code turn the answers into moves. 4. jev-drone A camera-only autonomous drone in MuJoCo with a Jev judgment model sitting in the control loop at 2.5 Hz. 5. robo-harness A real SO-101 robot arm workbench where Jev picks bounded joint steps from typed candidate actions under a spend budget. 6. fast-jev-compaction Claude Code plugin that replaces the compaction summary with Jev decisions, scoring every tool call for whether it is still needed. 7. jev-claude Routes Claude Code's own judgment calls through Jev: typed choices with probabilities at plan approval, on questions, and before risky commands. 8. is-malicious Supply-chain check before you run anything: Jev Noul checks over source and build files, returning the implicated files and lines. 9. sqlite-jev Jev inside SQL. Noul, Choice and Score judgments exposed as SQLite functions, with confidence on every row. 10. jevinci Paints images by having Jev predict every pixel's colour in parallel, with confidence deciding how wide each stroke is drawn. Copy these complete Jev blueprints - then read full Jev setup below ↓ ↓

Hanako

29,629 Aufrufe • vor 9 Tagen

THIS GUY CONNECTED HIS AI AGENTS TO HIS OBSIDIAN AND BUILT A BRAIN THAT LEARNS ON ITS OWN. HERE'S HOW TO BUILD IT Obsidian is just markdown files sitting in a folder. That turns out to be the perfect memory for an AI agent, because an agent can read and write those files directly. He wired his agents into the vault so they pull context from it, do the work, and write what they learned back. The notes aren't the point. The loop is, and it gets sharper every cycle How to build it: 1. Point an agent at your vault. The fastest way, no plugins, no API keys: open a terminal and run npx obsidian-mcp /path/to/your/vault. That exposes your Obsidian folder to Claude as a tool it can read, search, and write to. Add it to your Claude Code or Cowork config and restart 2. Confirm it can see the brain. Ask it: "list the notes in my vault and summarize what's in them." If it reads them back, the connection is live. Now it starts every task with everything the vault already holds instead of from zero 3. Give each agent one job and a write-back rule. Tell it: "research this, then save what you found as a new note in /brain with links to related notes." One agent researches, one summarizes, one plans. Each writes its output back into the vault 4. Close the loop. Add one line to every agent's instructions: "read /brain before starting, write your result back when done." Now each task leaves the vault richer, and the next run reads that before it works. It compounds instead of resetting 5. You only steer. Review what the brain produces, point it at the next thing. The agents handle the reading, writing, and connecting The edge isn't better notes. It's a brain that feeds itself, so the work gets sharper every cycle instead of starting over Bookmark this

Yarchi

58,591 Aufrufe • vor 3 Monaten

Another insane Jev use case! Jev is making it dramatically cheaper to evaluate what actually happened inside an agent run. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode, and 20+ more Beacon by Asymptote Labs continuously captures your agent history across harnesses and uses Jev to identify which runs are actually worth learning from. It then turns the highest-signal workflows, corrections, and debugging patterns into reusable skills. GitHub repo: (don’t forget to star it ⭐ ) Beacon preserves the complete session history. But preserving a run and learning from it are two different things. Most coding-agent sessions contain routine exploration, failed commands, and fixes that only apply to one task. The trace can remain available for inspection without turning every detail into guidance for future agents. Jev scores each run for evidence, reuse potential, and human correction signals. An application policy then decides whether to promote, review, or discard it. The recording shows this in action. Claude receives a coding task, modifies the implementation, and runs the tests. I then provide an edge-case correction, so Claude updates the code and adds regression coverage. Beacon automatically captures the complete session. Jev evaluates whether the correction contains a reusable engineering lesson. Once approved, that lesson becomes available to other coding agents working on the project. Since it works across harnesses: - Claude Code sessions can teach Codex. - Cursor debugging can improve OpenCode. So a problem solved by one agent should not need to be learned from scratch by another. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

291,153 Aufrufe • vor 13 Tagen