Loading video...

Video Failed to Load

There was a problem loading this video. This could be due to a temporary network issue or the video might be unavailable.

Jev Engineering changes the unit of optimization from “agent” to “decision.” that sounds small, but it changes the architecture. and up to 193x faster and 444x cheaper in tests. normal multi-agent stack: agent → prompt → tool → output Jev-style stack: shared state → decision boundary → selected branch... → execution → measurement → state update now you can optimize the actual control points: latency per decision cost per fork confidence threshold retry policy branch survival termination condition the agents underneath can change. the models can change. the tools can change. the decision layer stays measurable. that’s why Jev Engineering feels more like systems engineering than prompt engineering.show more

Ricker

11,854 subscribers

22,469 views • 1 month ago •via X (Twitter)

Science & Technology

Anya Rossi• Live Now

Private livecam show

19 Comments

Morty1 month ago

Perfect explain of Jev work

Ricker1 month ago

thanks, do my best

Apex1 month ago

Brilliant quote

Ricker1 month ago

glad that you enjoy

Hussain Hashim | Building SundayBack1 month ago

@0xRicker interesting approach. watch out for state bloat tho, especially if scaling rapidly. had to tackle that in my own projects, keeping the shared state lean was key.

Flux1 month ago

visual really help to understand

DHRUV BANSAL1 month ago

whatever layer stays fixed is the one you're stuck with. drawn first... before anything has run

BG繁70青禾1 month ago

这降维打击太狠了直接重构逻辑底层

rewind1 month ago

Good point

Slonski1 month ago

models can swap the control points have to stay measurable

Argona1 month ago

that jev floor visual is beautiful work

Sofie e1 month ago

Decisions as the unit makes sense for scaling, but doesn't that just push the complexity into the shared state layer? How do you prevent that from becoming the new bottleneck?

Zero1 month ago

wait, is this squid game?

♡ ΜạĹĹdiiTạ´Enạnạ ♡1 month ago

生まれ変わるなら、どんな職業に就いてみたいですか。今日も一日お疲れ様！ 🎉

Knight 🐜1 month ago

shared state is the bit that makes this shippable. fewer agents, fewer stale tool calls.

翻70·BG小晴1 month ago

把决策从个体里剥离出来架构思路太顶了

Crio Songo1 month ago

This shift of optimization unit is really clever, the speedup and cost cut are super impressive.

sophia a.1 month ago

Totally agree with this

OK烦50星河1 month ago

优化单位变了思维逻辑确实完全不同

Related Videos

Jev Engineering is the layer most agent stacks are still missing. state → decision → action → verification → next state up to 193x faster and 444x cheaper in our tests. everyone is optimizing the model. Jev Engineering optimizes what happens between model calls. every agent eventually hits the same fork: state → multiple possible actions → one route has to win instead of sending every decision back to an expensive LLM call, Jev turns that into a dedicated layer: so the loop becomes: LLM → reason Jev → decide tools / agents → execute state → update Jev → decide again once decisions become their own engineering layer, you can benchmark, batch and verify them separately. full blueprint in article ↓

Jev Engineering is the layer most agent stacks are still missing. state → decision → action → verification → next state up to 193x faster and 444x cheaper in our tests. everyone is optimizing the model. Jev Engineering optimizes what happens between model calls. every agent eventually hits the same fork: state → multiple possible actions → one route has to win instead of sending every decision back to an expensive LLM call, Jev turns that into a dedicated layer: so the loop becomes: LLM → reason Jev → decide tools / agents → execute state → update Jev → decide again once decisions become their own engineering layer, you can benchmark, batch and verify them separately. full blueprint in article ↓

Ricker

116,701 views • 1 month ago

Jev Engineering turns one agent chain into a decision graph that can reroute itself and moves the expensive model out of every decision loop. the important part in this setup isn’t the number of agents. it’s that execution doesn’t follow one fixed path. and up to 193x faster and 444x cheaper in tests. every result can change what happens next: state → Jev decision → branch → specialist agent → result → score → reroute and Jev Engineering sits above that graph deciding: which route stays alive → which specialist gets control → when two branches should merge → when a result needs another pass → when the goal is good enough to stop by the end of the run: 5,400 executions → 0.93 goal score → $0.020 decision cost that’s why Jev Engineering is more than model routing. it’s the control layer that keeps a changing agent graph pointed at one objective. full breakdown below ↓

Jev Engineering turns one agent chain into a decision graph that can reroute itself and moves the expensive model out of every decision loop. the important part in this setup isn’t the number of agents. it’s that execution doesn’t follow one fixed path. and up to 193x faster and 444x cheaper in tests. every result can change what happens next: state → Jev decision → branch → specialist agent → result → score → reroute and Jev Engineering sits above that graph deciding: which route stays alive → which specialist gets control → when two branches should merge → when a result needs another pass → when the goal is good enough to stop by the end of the run: 5,400 executions → 0.93 goal score → $0.020 decision cost that’s why Jev Engineering is more than model routing. it’s the control layer that keeps a changing agent graph pointed at one objective. full breakdown below ↓

Ricker

13,896 views • 1 month ago

Jev Engineering is what lets one decision layer control hundreds of agent paths without turning the system into chaos. and up to 193x faster and 444x cheaper in tests. it’s deciding: → which model gets called → which tool gets access → which result survives that’s what the video is showing. one state enters. Jev turns it into structured decisions. those decisions fan out across dozens of routes, agents and tools. then everything collapses back into one verified state. so instead of: LLM → agent → tool → another LLM → another guess you get: state → Jev decision layer → parallel routes → execution → verification → next state that’s the point of Jev Engineering: more parallelism without giving every branch permission to improvise. full breakdown in the article below ↓

Jev Engineering is what lets one decision layer control hundreds of agent paths without turning the system into chaos. and up to 193x faster and 444x cheaper in tests. it’s deciding: → which model gets called → which tool gets access → which result survives that’s what the video is showing. one state enters. Jev turns it into structured decisions. those decisions fan out across dozens of routes, agents and tools. then everything collapses back into one verified state. so instead of: LLM → agent → tool → another LLM → another guess you get: state → Jev decision layer → parallel routes → execution → verification → next state that’s the point of Jev Engineering: more parallelism without giving every branch permission to improvise. full breakdown in the article below ↓

Ricker

57,821 views • 1 month ago

Jev Engineering is what turns a messy agent graph into a controlled decision loop. and up to 193x faster and 444x cheaper in tests. the video looks complex, but the idea is simple: Jev Engineering makes that decision explicit. state enters → routes get scored → confidence updates → weak branches die → strong branches keep moving → execution unlocks so instead of every agent improvising independently, the system keeps narrowing the graph. 0.00 → 0.41 → 0.68 → 0.80 → 0.93 and that score can decide: which model runs → which tool gets called → which branch retries → which result gets rejected that’s the point of Jev Engineering: don’t just give agents more intelligence. engineer how they make decisions. full breakdown guide below

Jev Engineering is what turns a messy agent graph into a controlled decision loop. and up to 193x faster and 444x cheaper in tests. the video looks complex, but the idea is simple: Jev Engineering makes that decision explicit. state enters → routes get scored → confidence updates → weak branches die → strong branches keep moving → execution unlocks so instead of every agent improvising independently, the system keeps narrowing the graph. 0.00 → 0.41 → 0.68 → 0.80 → 0.93 and that score can decide: which model runs → which tool gets called → which branch retries → which result gets rejected that’s the point of Jev Engineering: don’t just give agents more intelligence. engineer how they make decisions. full breakdown guide below

Ricker

19,376 views • 1 month ago

Jev Engineering turns a static agent workflow into a graph that can rewrite itself while running. the video is basically the problem at scale: hundreds of routes → thousands of crossings → different agents → different tools → different confidence levels Jev Engineering doesn’t control every step. it controls the crossings. when two paths compete: → score both → kill the weak route → reroute the task so instead of one fixed chain, you get a live braid: state → decision → parallel paths → crossings → Jev → next state that’s the point of Jev Engineering: more parallel execution without letting the system lose the objective. the agents create the paths. Jev decides which paths survive. full breakdown below ↓

Jev Engineering turns a static agent workflow into a graph that can rewrite itself while running. the video is basically the problem at scale: hundreds of routes → thousands of crossings → different agents → different tools → different confidence levels Jev Engineering doesn’t control every step. it controls the crossings. when two paths compete: → score both → kill the weak route → reroute the task so instead of one fixed chain, you get a live braid: state → decision → parallel paths → crossings → Jev → next state that’s the point of Jev Engineering: more parallel execution without letting the system lose the objective. the agents create the paths. Jev decides which paths survive. full breakdown below ↓

Ricker

11,506 views • 1 month ago

Jev Engineering ran 5,400 agent executions and sent exactly 0 decisions back to me. that’s the number i care about here. and up to 193x faster and 444x cheaper in tests. 18 turns → 300 agents → 5,400 runs → 43 Jev calls → 16 outputs kept → 0 human escalations the loop handled three decisions around every turn: Choice → Score → Noul then it stopped itself when the goal crossed 0.93 vs 0.85 required. that’s what Jev Engineering looks like when it works: not “more autonomous agents.” fewer reasons for the human to come back into the loop.

Jev Engineering ran 5,400 agent executions and sent exactly 0 decisions back to me. that’s the number i care about here. and up to 193x faster and 444x cheaper in tests. 18 turns → 300 agents → 5,400 runs → 43 Jev calls → 16 outputs kept → 0 human escalations the loop handled three decisions around every turn: Choice → Score → Noul then it stopped itself when the goal crossed 0.93 vs 0.85 required. that’s what Jev Engineering looks like when it works: not “more autonomous agents.” fewer reasons for the human to come back into the loop.

Ricker

13,329 views • 1 month ago

Jev Engineering transforms a collection of AI agents into a full-fledged management system while eliminating heavy, expensive models from every decision-making loop Speed: +19,000% Costs: -99.7% How this architecture works: Gatekeeper Request Mini-Model Validation Tool Router State Worker Management layers avoid generating detailed text and instead focus on directing, evaluating, blocking, or permitting Route -> Score -> Block -> Approve As a result, resource-intensive models are invoked exclusively when the task truly requires it This is the essence of Jev Engineering: to decouple reasoning from decision-making, making the decision-making layer fast, cheap, and easily quantifiable Detailed instructions in the article below

Jev Engineering transforms a collection of AI agents into a full-fledged management system while eliminating heavy, expensive models from every decision-making loop Speed: +19,000% Costs: -99.7% How this architecture works: Gatekeeper Request Mini-Model Validation Tool Router State Worker Management layers avoid generating detailed text and instead focus on directing, evaluating, blocking, or permitting Route -> Score -> Block -> Approve As a result, resource-intensive models are invoked exclusively when the task truly requires it This is the essence of Jev Engineering: to decouple reasoning from decision-making, making the decision-making layer fast, cheap, and easily quantifiable Detailed instructions in the article below

Bober_smart

13,950 views • 1 month ago

Your agent doesn't know Jev. Most code calls LLMs the long way: state → prompt → text → parse → if statement Decision models like Jev skip the text and plug into your logic. Here's 30 minutes with TypeSafe AI's Allie the Icon on building with it.

Your agent doesn't know Jev. Most code calls LLMs the long way: state → prompt → text → parse → if statement Decision models like Jev skip the text and plug into your logic. Here's 30 minutes with TypeSafe AI's Allie the Icon on building with it.

CodeRabbit

15,521 views • 1 month ago

He is 18 teaching AI at Stanford making $2.2M on agents - and in 60 minutes revealed how to repeat it from zero: 00:30 - 5% who build agents will replace the 95% who just use them 38:33 - Jev Engineering is the only thing you need to make $2.2M on an agent 52:47 - Claude + Jev 10x cheaper and faster right now after watching I built my first agent with Jev in 15 minutes and sold it to a million dollar company for $100k: save & watch - the article below shows how to use Jev Engineering to make Claude 10x cheaper and build a $2.2M agent.

He is 18 teaching AI at Stanford making $2.2M on agents - and in 60 minutes revealed how to repeat it from zero: 00:30 - 5% who build agents will replace the 95% who just use them 38:33 - Jev Engineering is the only thing you need to make $2.2M on an agent 52:47 - Claude + Jev 10x cheaper and faster right now after watching I built my first agent with Jev in 15 minutes and sold it to a million dollar company for $100k: save & watch - the article below shows how to use Jev Engineering to make Claude 10x cheaper and build a $2.2M agent.

Noisy

13,407 views • 1 month ago

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to 100 agents running inside one graph: 17:44 - Build your first AI agent 39:30 - Run agents with loop engineering 1:12:38 - Turn agent loops into graphs 1:34:26 - Build agents that throttle themselves 1:55:05 - Orchestrate the full multi-agent system Most people build one agent and stop there. Google is teaching the full stack: Prompt → Agents → Loops → Graphs → Multi-Agent Systems Single agents are the old workflow. Self-regulating agent graphs are the new one. This 2-hour watch is worth more than most paid agent engineering courses. Bookmark and watch it today Then read the full architecture below ↓

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to 100 agents running inside one graph: 17:44 - Build your first AI agent 39:30 - Run agents with loop engineering 1:12:38 - Turn agent loops into graphs 1:34:26 - Build agents that throttle themselves 1:55:05 - Orchestrate the full multi-agent system Most people build one agent and stop there. Google is teaching the full stack: Prompt → Agents → Loops → Graphs → Multi-Agent Systems Single agents are the old workflow. Self-regulating agent graphs are the new one. This 2-hour watch is worth more than most paid agent engineering courses. Bookmark and watch it today Then read the full architecture below ↓

Lunar

405,195 views • 3 months ago

jev + opus 5.5 is one of those setups that makes agent architecture feel weirdly overcomplicated in hindsight. the useful split isn’t “small model vs big model.” it’s deciding which calls actually need generation at all. → jev routes the next worker → scores which context is worth keeping → catches repeated actions before they burn the run → gates risky tool calls and sends uncertainty to review opus still owns the expensive part: planning, writing, coding, synthesis. jev sits around it as the decision layer. that matters because a typical loop can have 11 decision points but only 2 real generation calls. once those are separated, latency and cost stop scaling with every tiny fork in the workflow.

jev + opus 5.5 is one of those setups that makes agent architecture feel weirdly overcomplicated in hindsight. the useful split isn’t “small model vs big model.” it’s deciding which calls actually need generation at all. → jev routes the next worker → scores which context is worth keeping → catches repeated actions before they burn the run → gates risky tool calls and sends uncertainty to review opus still owns the expensive part: planning, writing, coding, synthesis. jev sits around it as the decision layer. that matters because a typical loop can have 11 decision points but only 2 real generation calls. once those are separated, latency and cost stop scaling with every tiny fork in the workflow.

Gipp 🦅

51,452 views • 1 month ago

Another insane way to use Jev: Jev makes it dramatically cheaper to identify which corrections and trajectories from an agent run are reusable across agents. 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 - Hermes, and 20+ more Beacon by Asymptote Labs continuously captures agent sessions across harnesses and stores their traces in a shared index. I used it with Jev to build a live cross-agent memory workflow. Beacon captures each run as it happens across all harnesses on my machine. Then Jev evaluates whether the trace contains a reusable engineering lesson, and the approved lesson becomes available to the next agent. GitHub repo: (don't forget to star it ⭐) Preserving an agent run and learning from it are two different problems. Most traces contain file reads, failed commands, routine exploration, and implementation details that only apply to one task. Passing the complete transcript to another agent adds context without identifying what matters. In this workflow, one agent never receives another agent's raw transcript. It receives only the specific engineering lesson produced from the evaluated trace. A correction made in one agent can then prevent the same mistake when another agent encounters a similar problem. The recording shows the complete workflow I built. 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.

Another insane way to use Jev: Jev makes it dramatically cheaper to identify which corrections and trajectories from an agent run are reusable across agents. 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 - Hermes, and 20+ more Beacon by Asymptote Labs continuously captures agent sessions across harnesses and stores their traces in a shared index. I used it with Jev to build a live cross-agent memory workflow. Beacon captures each run as it happens across all harnesses on my machine. Then Jev evaluates whether the trace contains a reusable engineering lesson, and the approved lesson becomes available to the next agent. GitHub repo: (don't forget to star it ⭐) Preserving an agent run and learning from it are two different problems. Most traces contain file reads, failed commands, routine exploration, and implementation details that only apply to one task. Passing the complete transcript to another agent adds context without identifying what matters. In this workflow, one agent never receives another agent's raw transcript. It receives only the specific engineering lesson produced from the evaluated trace. A correction made in one agent can then prevent the same mistake when another agent encounters a similar problem. The recording shows the complete workflow I built. 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

71,748 views • 22 days ago

Everyone is talking about JEV. Almost nobody knows how to actually use it. These 10 GitHub repos fix that. 1. browser-use/jev-ultrafast (~16.6k⭐) Jev for browser agents: pick the next action without another expensive LLM call. 2. tamaratran/fast-jev-compaction (~6.5k⭐) Uses Jev to decide what context still matters and what can be dropped. 3. TheoLeeCJ/SemIf (~4k⭐) Open-source Jev-style decision making you can run locally. 4. jarrodwatts/jev-trader (~2.1k⭐) Real-time trading loop where Jev decides buy, sell or wait. 5. kerpopule/hermes-jev-skills (~670⭐) Jev routing, memory, compaction and skill selection for AI agents. 6. devagrawal09/jev-review (~570⭐) Code review powered by Jev decisions instead of one giant prompt. 7. thruwire/foreman (~520⭐) Jev as a supervisor for coding agents: continue, retry, verify or stop. 8. superagents-lab/jev-search (~400⭐) Jev decides where and how an agent should search. 9. droidrun/mobile-jev (~350⭐) Jev for Android agents choosing the next app action. 10. gargpratyush/jev-router (~340⭐) Routes agent tasks to the right model with Jev. After looking through these, the pattern is pretty clear: LLMs generate. Agents execute. JEV decides. That decision layer is what most agent stacks are still missing. Save this if you want to integrate Jev into your workflow👇

Everyone is talking about JEV. Almost nobody knows how to actually use it. These 10 GitHub repos fix that. 1. browser-use/jev-ultrafast (~16.6k⭐) Jev for browser agents: pick the next action without another expensive LLM call. 2. tamaratran/fast-jev-compaction (~6.5k⭐) Uses Jev to decide what context still matters and what can be dropped. 3. TheoLeeCJ/SemIf (~4k⭐) Open-source Jev-style decision making you can run locally. 4. jarrodwatts/jev-trader (~2.1k⭐) Real-time trading loop where Jev decides buy, sell or wait. 5. kerpopule/hermes-jev-skills (~670⭐) Jev routing, memory, compaction and skill selection for AI agents. 6. devagrawal09/jev-review (~570⭐) Code review powered by Jev decisions instead of one giant prompt. 7. thruwire/foreman (~520⭐) Jev as a supervisor for coding agents: continue, retry, verify or stop. 8. superagents-lab/jev-search (~400⭐) Jev decides where and how an agent should search. 9. droidrun/mobile-jev (~350⭐) Jev for Android agents choosing the next app action. 10. gargpratyush/jev-router (~340⭐) Routes agent tasks to the right model with Jev. After looking through these, the pattern is pretty clear: LLMs generate. Agents execute. JEV decides. That decision layer is what most agent stacks are still missing. Save this if you want to integrate Jev into your workflow👇

unicode

20,745 views • 1 month ago

Introducing d3-turbo: our newest state-of-the-art multimodal foundation decision model⚡ #1 on both Jev Decision Index boards. It points(box), follows and sees images in your questions. StateOnce brings 15x faster than d3 flash 🤗 #vLLM #Jev #Decision

Introducing d3-turbo: our newest state-of-the-art multimodal foundation decision model⚡ #1 on both Jev Decision Index boards. It points(box), follows and sees images in your questions. StateOnce brings 15x faster than d3 flash 🤗 #vLLM #Jev #Decision

Xunzhuo

21,223 views • 24 days ago

Most AI tools generate answers. But engineering is about making the right decisions. Meet the new PatSnap Eureka Engineering — a collaborative R&D AI Agent that helps teams move faster from search → decision-ready plans. Try PatSnap Eureka Engineering today.

Most AI tools generate answers. But engineering is about making the right decisions. Meet the new PatSnap Eureka Engineering — a collaborative R&D AI Agent that helps teams move faster from search → decision-ready plans. Try PatSnap Eureka Engineering today.

Patsnap Eureka

3,109,522 views • 7 months ago

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to 100 agents running inside a single graph: 0% → 17:44 - build your first AI agent 25% → 39:30 - run agents with loop engineering 50% → 1:12:38 - turn agent loops into graphs 75% → 1:34:26 - build agents that regulate themselves 100% → 1:55:05 - orchestrate the entire multi-agent system Most people build one agent and stop there. Google is teaching the entire stack: Prompt → Agents → Loops → Graphs → Multi-Agent Systems Single agents are the old workflow. Self-regulating agent graphs are the next one. This 2-hour course is worth more than most paid agent engineering courses. Bookmark it and watch today Then read the full architecture below ↓

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to 100 agents running inside a single graph: 0% → 17:44 - build your first AI agent 25% → 39:30 - run agents with loop engineering 50% → 1:12:38 - turn agent loops into graphs 75% → 1:34:26 - build agents that regulate themselves 100% → 1:55:05 - orchestrate the entire multi-agent system Most people build one agent and stop there. Google is teaching the entire stack: Prompt → Agents → Loops → Graphs → Multi-Agent Systems Single agents are the old workflow. Self-regulating agent graphs are the next one. This 2-hour course is worth more than most paid agent engineering courses. Bookmark it and watch today Then read the full architecture below ↓

Lunar

12,509 views • 2 months ago

Introducing Drex - a lightning-fast decision model built to rival Jev. #1 on the Decision Index. (official scores tbd) winning 23 out of 40 benchmarks Architecture: Small Diffusion Model with RLAF Price: $0.04 per 1M input tokens (cheaper than Jev) Latency: less than a second. Sign up now for 250M welcome credits. Open weights and the full tech report are coming very soon. 👀 🦖 #jev #nace #drex

Introducing Drex - a lightning-fast decision model built to rival Jev. #1 on the Decision Index. (official scores tbd) winning 23 out of 40 benchmarks Architecture: Small Diffusion Model with RLAF Price: $0.04 per 1M input tokens (cheaper than Jev) Latency: less than a second. Sign up now for 250M welcome credits. Open weights and the full tech report are coming very soon. 👀 🦖 #jev #nace #drex

Nace AI

639,893 views • 1 month ago

$this harness stack is f*cking gold TypeSafe AI + LangChain finally dropped the layer that makes agents affordable at company scale: jev running inside the langchain agent loop as middleware the problem every big team hits: each fork in the loop is another full LLM call. at 10 agents that's a bill. at 10,000 it's the budget > routing before: every task goes to the frontier model now: jev picks the least costly model that can finish it. lookups go fast, architecture goes powerful > guardrails before: the "is this command dangerous?" check sat in the closed parts of claude code, codex, cursor now: AutoModeMiddleware(tools=["bash"]). one line, any agent, blocked before the tool runs > decisions before: one LLM call per question now: every question about the same state in one request, answered in parallel > audit before: "the model decided" now: the answer, the probability and the confidence stay in agent state > adoption no rewrite. pip install langchain-typesafe and drop it into the agent you already run TypeSafe reports up to 200x faster inference and 400x lower cost than comparable LLMs on classification. the LLM still reasons and writes. jev takes the thousands of small calls in between already live: browserbase agents for fractions of a cent, a live trading agent, email triage at scale full loop mapped below: 7 agents, 4 jev gates per step count the forks in your agent loop tonigh$

this harness stack is f*cking gold TypeSafe AI + LangChain finally dropped the layer that makes agents affordable at company scale: jev running inside the langchain agent loop as middleware the problem every big team hits: each fork in the loop is another full LLM call. at 10 agents that's a bill. at 10,000 it's the budget > routing before: every task goes to the frontier model now: jev picks the least costly model that can finish it. lookups go fast, architecture goes powerful > guardrails before: the "is this command dangerous?" check sat in the closed parts of claude code, codex, cursor now: AutoModeMiddleware(tools=["bash"]). one line, any agent, blocked before the tool runs > decisions before: one LLM call per question now: every question about the same state in one request, answered in parallel > audit before: "the model decided" now: the answer, the probability and the confidence stay in agent state > adoption no rewrite. pip install langchain-typesafe and drop it into the agent you already run TypeSafe reports up to 200x faster inference and 400x lower cost than comparable LLMs on classification. the LLM still reasons and writes. jev takes the thousands of small calls in between already live: browserbase agents for fractions of a cent, a live trading agent, email triage at scale full loop mapped below: 7 agents, 4 jev gates per step count the forks in your agent loop tonigh

NO1ennn

31,666 views • 1 month ago

this is pure f*cking treasure 10 GitHub projects that put Jev between your agent and every decision your agent should stop paying a frontier model to answer yes or no ROUTE THE WORK 01 jev-router > 02 jcm-router > 03 jev-agent-skill-router > GUARD EVERY ACTION 04 pi-heed > 05 fx > 06 Foreman > SCORE WHAT MATTERS 07 LlamaIndex Jev > 08 citation-verifier > PUT IT TO WORK 09 yoshi > 10 mastra-jev-moderation > the loop: your agent hits a fork > Jev answers with a probability > your code decides what that number allows > the agent moves on 3 builds I'd explore: coding agent: jev-router > fx > Foreman > yoshi support desk: jev-agent-skill-router > mastra-jev-moderation > LlamaIndex Jev research: jcm-router > pi-heed > citation-verifier save this, then build a decision layer for your agents ⭣

this is pure f*cking treasure 10 GitHub projects that put Jev between your agent and every decision your agent should stop paying a frontier model to answer yes or no ROUTE THE WORK 01 jev-router > 02 jcm-router > 03 jev-agent-skill-router > GUARD EVERY ACTION 04 pi-heed > 05 fx > 06 Foreman > SCORE WHAT MATTERS 07 LlamaIndex Jev > 08 citation-verifier > PUT IT TO WORK 09 yoshi > 10 mastra-jev-moderation > the loop: your agent hits a fork > Jev answers with a probability > your code decides what that number allows > the agent moves on 3 builds I'd explore: coding agent: jev-router > fx > Foreman > yoshi support desk: jev-agent-skill-router > mastra-jev-moderation > LlamaIndex Jev research: jcm-router > pi-heed > citation-verifier save this, then build a decision layer for your agents ⭣

delost

16,024 views • 1 month ago

your agent is not the loop the loop is only the smallest layer LOOP vs GRAPH vs HARNESS ENGINEERING most teams still treat all three like one prompt that is why agent failures feel impossible to diagnose LOOP ENGINEERING controls iteration turns retries budgets evaluators exits stalled progress when the run keeps going forever the loop is broken make long-running work survive crashes and restarts → GRAPH ENGINEERING controls structure nodes edges state branches cycles joins checkpoints when the agent takes the wrong path the graph is broken make state and routing explicit → inspect the topology without asking another model to explain it → HARNESS ENGINEERING controls access tools permissions memory sandboxes evals traces humans when the agent touches the wrong system the harness is broken isolate generated code and tool execution from the host → put an eval gate before every model or prompt update → keep one trace across every node model and tool call → without loop engineering it never stops without graph engineering you cannot see the path without harness engineering it can reach anything the prompt lives inside the loop the loop lives inside the graph the graph lives inside the harness the model is the smallest box in the system debug the layer that actually owns the failure save this before the next agent rewrite

your agent is not the loop the loop is only the smallest layer LOOP vs GRAPH vs HARNESS ENGINEERING most teams still treat all three like one prompt that is why agent failures feel impossible to diagnose LOOP ENGINEERING controls iteration turns retries budgets evaluators exits stalled progress when the run keeps going forever the loop is broken make long-running work survive crashes and restarts → GRAPH ENGINEERING controls structure nodes edges state branches cycles joins checkpoints when the agent takes the wrong path the graph is broken make state and routing explicit → inspect the topology without asking another model to explain it → HARNESS ENGINEERING controls access tools permissions memory sandboxes evals traces humans when the agent touches the wrong system the harness is broken isolate generated code and tool execution from the host → put an eval gate before every model or prompt update → keep one trace across every node model and tool call → without loop engineering it never stops without graph engineering you cannot see the path without harness engineering it can reach anything the prompt lives inside the loop the loop lives inside the graph the graph lives inside the harness the model is the smallest box in the system debug the layer that actually owns the failure save this before the next agent rewrite

elune

16,875 views • 3 months ago