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

10,629 subscribers

21,662 views • 2 days ago •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

19 Comments

Morty2 days ago

Perfect explain of Jev work

Ricker2 days ago

thanks, do my best

Apex2 days ago

Brilliant quote

Ricker2 days ago

glad that you enjoy

Hussain Hashim | Building SundayBack2 days 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.

Flux2 days ago

visual really help to understand

DHRUV BANSAL2 days ago

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

BG繁70青禾2 days ago

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

rewind2 days ago

Good point

Slonski2 days ago

models can swap the control points have to stay measurable

Argona2 days ago

that jev floor visual is beautiful work

Sofie e2 days 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?

Zero2 days ago

wait, is this squid game?

♡ ΜạĹĹdiiTạ´Enạnạ ♡2 days ago

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

Knight 🐜2 days ago

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

翻70·BG小晴1 day ago

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

Crio Songo2 days ago

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

sophia a.2 days ago

Totally agree with this

OK烦50星河2 days 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 • 8 days 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,777 views • 4 days 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

44,743 views • 6 days 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 • 5 days 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,145 views • 3 days 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

403,235 views • 1 month 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 🦅

49,670 views • 1 day 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 • 4 days 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,020 views • 25 days ago

Corent’s brain uses TypeSafe AI Jev now. Not to generate the output, to make the decision before the output gets generated. When a request comes into Corent, you don’t need to tell us which model to use. You send the prompt, the workload and the quality level. Then Jev helps us decide what that request actually needs, how confident we are in that decision, and whether we should take the route or fall back to something safer. That matters because every request has different economics. A 2¢ image can tolerate more uncertainty. A $2 video clip cannot. Across 1000+ models, this changes how we route. We can set different confidence requirements depending on the workload, the cost and the quality expected. If the confidence is too low, we stop guessing. Routing was never really a text problem. It was a decision problem. Diogo Almeida and the team did a wonderful job with JEV Get your key at

Corent’s brain uses TypeSafe AI Jev now. Not to generate the output, to make the decision before the output gets generated. When a request comes into Corent, you don’t need to tell us which model to use. You send the prompt, the workload and the quality level. Then Jev helps us decide what that request actually needs, how confident we are in that decision, and whether we should take the route or fall back to something safer. That matters because every request has different economics. A 2¢ image can tolerate more uncertainty. A $2 video clip cannot. Across 1000+ models, this changes how we route. We can set different confidence requirements depending on the workload, the cost and the quality expected. If the confidence is too low, we stop guessing. Routing was never really a text problem. It was a decision problem. Diogo Almeida and the team did a wonderful job with JEV Get your key at

corent

109,541 views • 9 days ago

Google just released a free 2-hour+ course on full agent engineering. How to go from one prompt to a system that runs while you sleep: 38:46 - Build your first AI agent 54:46 - Connect MCP tools 1:12:43 - Run agents with four loop patterns 1:20:57 - Turn agent loops into graphs 2:22:31 - Build the complete autonomous system Most people are still building one agent and stopping there. Google is already teaching the full stack: Agents → Tools → Loops → Graphs → Autonomous Systems Single agents are the old workflow. Systems that run without you are the new one. This course is worth more than most paid agent engineering bootcamps. Bookmark and watch it today Then read the full graph engineering playbook below

Google just released a free 2-hour+ course on full agent engineering. How to go from one prompt to a system that runs while you sleep: 38:46 - Build your first AI agent 54:46 - Connect MCP tools 1:12:43 - Run agents with four loop patterns 1:20:57 - Turn agent loops into graphs 2:22:31 - Build the complete autonomous system Most people are still building one agent and stopping there. Google is already teaching the full stack: Agents → Tools → Loops → Graphs → Autonomous Systems Single agents are the old workflow. Systems that run without you are the new one. This course is worth more than most paid agent engineering bootcamps. Bookmark and watch it today Then read the full graph engineering playbook below

Lunar

198,150 views • 1 month ago

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

kocer

31,162 views • 28 days ago

CONTEXT ENGINEERING > PROMPT ENGINEERING Everyone is obsessed with writing better prompts. The next generation of AI builders is focused on context engineering instead. • Prompt engineering shapes the question. Context engineering shapes everything the AI sees. • Great prompts can't save an agent missing critical context, memory, or tools. • AI failures often come from missing information, not weak models. • Context engineering combines prompts, memory, RAG, state management, and tool access into one system. What powers effective AI agents? → Memory: Remembers preferences, past interactions, and ongoing tasks. → State Management: Tracks progress across multi-step workflows. → RAG: Retrieves only the most relevant information when needed. → Tools: Connects AI to APIs, databases, code execution, and real-world actions. → Dynamic Prompts: Enriches instructions with live context at runtime. The key insight: Prompt Engineering = Better Questions Context Engineering = Better Systems The future of AI isn't building smarter prompts. It's building smarter environments for AI to think, remember, retrieve, and act.

CONTEXT ENGINEERING > PROMPT ENGINEERING Everyone is obsessed with writing better prompts. The next generation of AI builders is focused on context engineering instead. • Prompt engineering shapes the question. Context engineering shapes everything the AI sees. • Great prompts can't save an agent missing critical context, memory, or tools. • AI failures often come from missing information, not weak models. • Context engineering combines prompts, memory, RAG, state management, and tool access into one system. What powers effective AI agents? → Memory: Remembers preferences, past interactions, and ongoing tasks. → State Management: Tracks progress across multi-step workflows. → RAG: Retrieves only the most relevant information when needed. → Tools: Connects AI to APIs, databases, code execution, and real-world actions. → Dynamic Prompts: Enriches instructions with live context at runtime. The key insight: Prompt Engineering = Better Questions Context Engineering = Better Systems The future of AI isn't building smarter prompts. It's building smarter environments for AI to think, remember, retrieve, and act.

Dami-Defi

10,127 views • 3 months ago

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.

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

288,102 views • 6 days ago

Ex-Google engineer just compressed the shift from AI agents to "graphs" and "loops" into one 2h47m lecture: • 00:00 - understanding the different layers of AI memory • 30:00 - moving from simple LLM calls to AI agents • 50:00 - why agent systems are becoming a graph engineering problem • 1:12:00 - connecting context, tools and agent state • 1:24:00 - building a minimal agent harness from scratch • 1:46:00 - breaking down the architecture behind Hermes Agent • 2:08:00 - turning agent concepts into working systems 167-minute deep dive, and one of the clearest ways to understand how AI engineering is moving beyond prompts The progression: Prompt → Context → Memory → Agent → Loop → Graph → Agent Harness Watch it today, then read the full roadmap below

Ex-Google engineer just compressed the shift from AI agents to "graphs" and "loops" into one 2h47m lecture: • 00:00 - understanding the different layers of AI memory • 30:00 - moving from simple LLM calls to AI agents • 50:00 - why agent systems are becoming a graph engineering problem • 1:12:00 - connecting context, tools and agent state • 1:24:00 - building a minimal agent harness from scratch • 1:46:00 - breaking down the architecture behind Hermes Agent • 2:08:00 - turning agent concepts into working systems 167-minute deep dive, and one of the clearest ways to understand how AI engineering is moving beyond prompts The progression: Prompt → Context → Memory → Agent → Loop → Graph → Agent Harness Watch it today, then read the full roadmap below

Morlex

51,952 views • 1 month ago

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to an agent graph that can build itself: 0% → 10:16 - build your first AI agent 25% → 41:05 - master prompt engineering 50% → 54:45 - turn agents into graphs 75% → 1:20:10 - run loops inside agent graphs 100% → 1:43:33 - build a graph that builds itself Most people build one agent and stop there. Google is teaching everything that comes after: Prompt → Agents → Graphs → Loops → Self-Building Systems Single agents are the old workflow. Graphs that evolve themselves are the next one. This 2-hour course is worth more than most paid agent engineering courses. Bookmark it and watch today Then read how to run 1,000 agents from one prompt below ↓

Google just released a free 2-hour course on full Graph Engineering. How to go from one prompt to an agent graph that can build itself: 0% → 10:16 - build your first AI agent 25% → 41:05 - master prompt engineering 50% → 54:45 - turn agents into graphs 75% → 1:20:10 - run loops inside agent graphs 100% → 1:43:33 - build a graph that builds itself Most people build one agent and stop there. Google is teaching everything that comes after: Prompt → Agents → Graphs → Loops → Self-Building Systems Single agents are the old workflow. Graphs that evolve themselves are the next one. This 2-hour course is worth more than most paid agent engineering courses. Bookmark it and watch today Then read how to run 1,000 agents from one prompt below ↓

Lunar

44,744 views • 21 days ago

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.

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 🚀

116,880 views • 4 days ago

94% OF ENGINEERING ORGS USE AI. ONLY 6% SCALE IT The missing link is context and governance. That’s exactly what Atlassian is going after with its new agentic engineering stack: Code Context + governed agent loops in Atlassian Jira + DX measurement. The idea is simple: make agents a native part of your engineering system instead of a side quest in a terminal. > Code Context grounds them in your architecture > Governed loops take work from backlog to pull request > DX measures the impact And the data backs up the context thesis: DX found context-rich AI teams shipped ~64% more per developer 👊 A pretty strong signal that context is becoming one of the biggest leverage points in agentic engineering.

94% OF ENGINEERING ORGS USE AI. ONLY 6% SCALE IT The missing link is context and governance. That’s exactly what Atlassian is going after with its new agentic engineering stack: Code Context + governed agent loops in Atlassian Jira + DX measurement. The idea is simple: make agents a native part of your engineering system instead of a side quest in a terminal. > Code Context grounds them in your architecture > Governed loops take work from backlog to pull request > DX measures the impact And the data backs up the context thesis: DX found context-rich AI teams shipped ~64% more per developer 👊 A pretty strong signal that context is becoming one of the biggest leverage points in agentic engineering.

Charly Wargnier ♨️

29,622 views • 17 days ago

we’re launching Codag (Y Combinator S26) - the compression and control layer for agent tools. we started with logs. then customers pulled us into searches, tests, builds, and api responses. the pattern was always the same: agents burning context on repetitive output, with teams unable to see where the tokens went. Codag now cuts input-token usage ~3x at answer parity and gives teams visibility across their agent stack. agents are becoming the primary users of software - companies are adding agents, models, providers, and MCP servers faster than they can measure or control them. most cannot answer which tools their agents invoke, what those calls cost, or where the waste is. we’re building the layer between them and everything they read. 90+ engineering orgs already use Codag today to reduce that spend and see agent tool usage across provider. find out more and book a demo at

we’re launching Codag (Y Combinator S26) - the compression and control layer for agent tools. we started with logs. then customers pulled us into searches, tests, builds, and api responses. the pattern was always the same: agents burning context on repetitive output, with teams unable to see where the tokens went. Codag now cuts input-token usage ~3x at answer parity and gives teams visibility across their agent stack. agents are becoming the primary users of software - companies are adding agents, models, providers, and MCP servers faster than they can measure or control them. most cannot answer which tools their agents invoke, what those calls cost, or where the waste is. we’re building the layer between them and everything they read. 90+ engineering orgs already use Codag today to reduce that spend and see agent tool usage across provider. find out more and book a demo at

Michael Zhou

163,206 views • 1 month ago

Google just released a free 2-hour course On going from one prompt to a complete multi-agent graph: 17:44 - Build your first AI agent 39:30 - Create self-improving agent loops 1:12:38 - Connect those loops into graphs 1:34:26 - Make agents regulate themselves 1:55:05 - Orchestrate the full multi-agent system Most people are still building one agent and stopping 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 new one This free 2-hour course is worth more than most paid agent engineering programs Bookmark and watch it today Then read the full architecture below ↓

Google just released a free 2-hour course On going from one prompt to a complete multi-agent graph: 17:44 - Build your first AI agent 39:30 - Create self-improving agent loops 1:12:38 - Connect those loops into graphs 1:34:26 - Make agents regulate themselves 1:55:05 - Orchestrate the full multi-agent system Most people are still building one agent and stopping 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 new one This free 2-hour course is worth more than most paid agent engineering programs Bookmark and watch it today Then read the full architecture below ↓

rari

43,299 views • 1 month ago