正在加载视频...

视频加载失败

返回首页

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...

0xRicker's profile picture

Ricker

10,629 subscribers

13,777 次观看 • 4 天前 •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

17 条评论

Morty 的头像
Morty4 天前

Wow Ricker, this one is even better than previous

Ricker 的头像
Ricker4 天前

thanks, do my best

Apex 的头像
Apex4 天前

I should read it again

Ricker 的头像
Ricker4 天前

do it bro

Smarty 的头像
Smarty4 天前

it looks gorgeus

rewind 的头像
rewind4 天前

Need this, bro

Billy Moose 的头像
Billy Moose3 天前

That execution speed is impressive

Jason Wilson 的头像
Jason Wilson4 天前

Go build one stop posting other's attempts.

Atlas 的头像
Atlas4 天前

rerouting is powerful, but debugging a rerouted run gets difficult fast. we can make it possible to trace backward from the final result to the exact decision that changed the path

Akbar Shaik 的头像
Akbar Shaik4 天前

I like the distinction between agent count and decision architecture. You could have 300 agents and still have a terrible system if they all follow the same rigid workflow.

twinedon 的头像
twinedon4 天前

knowing when to stop is the hardest one there

Kai Lennox 的头像
Kai Lennox3 天前

that's the upgrade

Dominik 的头像
Dominik4 天前

this is the difference between an agent swarm and an agency architecture. a decision graph gives the system room to preserve state, change route, and stop when the goal is satisfied. the branch structure is where sovereignty starts to become measurable.

Jragyn's Claw 的头像
Jragyn's Claw4 天前

Most loops don't need the expensive model at all — they need the boring parts done fast and reliably. Taking the big brain out of the hot path is where agents actually become usable.

Slonski 的头像
Slonski4 天前

keep the expensive model off every loop let a cheap decision pick the next branch

h100envy 的头像
h100envy4 天前

very interesting scheme

magsimich 的头像
magsimich4 天前

Decision graphs change the whole flow

相关视频

Jev Engineering is what turns an agent stack into an actual control system and moves the expensive model out of every decision loop. and up to 193x faster and 444x cheaper in tests. the model shouldn’t decide everything. in this setup: request → structured state → Jev router → cheapest capable model → worker → relevance / approval checks → execution gate → tool the important part is that the decision layers don’t generate prose. they route → score → block → approve. so expensive models only get called when the task actually needs them. that’s the point of Jev Engineering: separate reasoning from decision-making, then make the decision layer measurable, cheap and fast. full breakdown in the article below ↓
0:39

Jev Engineering is what turns an agent stack into an actual control system and moves the expensive model out of every decision loop. and up to 193x faster and 444x cheaper in tests. the model shouldn’t decide everything. in this setup: request → structured state → Jev router → cheapest capable model → worker → relevance / approval checks → execution gate → tool the important part is that the decision layers don’t generate prose. they route → score → block → approve. so expensive models only get called when the task actually needs them. that’s the point of Jev Engineering: separate reasoning from decision-making, then make the decision layer measurable, cheap and fast. full breakdown in the article below ↓

Ricker

178,794 次观看 • 7 天前

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 ↓
0:34

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 次观看 • 6 天前

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 ↓
0:41

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 次观看 • 3 天前

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.
0:39

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.

Ricker

21,662 次观看 • 2 天前

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 ↓
0:29

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 次观看 • 8 天前

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.
0:24

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 次观看 • 1 天前

the loop is not the whole agent it is only one layer of the system LOOP vs GRAPH vs HARNESS ENGINEERING LOOP ENGINEERING controls iteration turns retries budgets stop conditions success checks stalled progress use durable execution when the run must survive crashes → GRAPH ENGINEERING controls structure nodes edges state branches checkpoints routing handoffs build stateful agents as explicit graphs → inspect the topology without putting a model in the loop → HARNESS ENGINEERING controls exposure tools permissions memory sandboxes evals traces humans isolate generated code from the host machine → test behavior before users ever see it → preserve one trace across every model step and tool call → without loop control it keeps running without graph structure the path stays invisible without harness control it can reach anything the loop runs inside the graph the graph runs inside the harness the model is only one component debug the layer that actually owns the failure save this then read the article below
0:20

the loop is not the whole agent it is only one layer of the system LOOP vs GRAPH vs HARNESS ENGINEERING LOOP ENGINEERING controls iteration turns retries budgets stop conditions success checks stalled progress use durable execution when the run must survive crashes → GRAPH ENGINEERING controls structure nodes edges state branches checkpoints routing handoffs build stateful agents as explicit graphs → inspect the topology without putting a model in the loop → HARNESS ENGINEERING controls exposure tools permissions memory sandboxes evals traces humans isolate generated code from the host machine → test behavior before users ever see it → preserve one trace across every model step and tool call → without loop control it keeps running without graph structure the path stays invisible without harness control it can reach anything the loop runs inside the graph the graph runs inside the harness the model is only one component debug the layer that actually owns the failure save this then read the article below

rari

20,934 次观看 • 1 个月前

one agent → a loop → a graph → a system that throttles itself Google just put the whole ladder in one free course. most people never leave the first rung. 2 hours 4 minutes, taught by two Google Cloud engineers. no signup, no paywall. 17:55 - build your first agent 39:55 - loop engineering: iterate, check, break 1:13:25 - graph engineering 1:35:27 - agents that throttle themselves 1:56:19 - the full graph for multi-agent systems the fourth one is the step nobody talks about. an agent that cannot throttle itself is not autonomous, it is just unattended. everyone builds one agent and calls it done. this is the version where the agents wire themselves into a graph and decide their own rate. and the thing that decides when one of them is allowed to stop is not in the course. that part you build yourself. bookmark and watch it today, then read the eval setup below
2:04:19

one agent → a loop → a graph → a system that throttles itself Google just put the whole ladder in one free course. most people never leave the first rung. 2 hours 4 minutes, taught by two Google Cloud engineers. no signup, no paywall. 17:55 - build your first agent 39:55 - loop engineering: iterate, check, break 1:13:25 - graph engineering 1:35:27 - agents that throttle themselves 1:56:19 - the full graph for multi-agent systems the fourth one is the step nobody talks about. an agent that cannot throttle itself is not autonomous, it is just unattended. everyone builds one agent and calls it done. this is the version where the agents wire themselves into a graph and decide their own rate. and the thing that decides when one of them is allowed to stop is not in the course. that part you build yourself. bookmark and watch it today, then read the eval setup below

Hanako

53,692 次观看 • 1 个月前

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👇
1:11

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 次观看 • 4 天前

Found a setup that replaces a team of researchers with 300 AI agents and one shared graph. the interesting part is what happens after all 300 come back with different pieces of the answer. because now you don’t have 300 agents. you have: 300 outputs → hundreds of sources → repeated entities → overlapping claims → contradictions → thousands of possible relationships and all of that has to collapse into one structure. that’s what the context graph is doing. instead of: agent → report you get: agents → sources → entities → edges → contradictions → verification → one graph every source becomes a node. every shared entity creates a connection. 300 agents can create information. the graph is what turns that information into memory the next agent can actually use. that’s the anatomy behind the setup ↓
0:33

Found a setup that replaces a team of researchers with 300 AI agents and one shared graph. the interesting part is what happens after all 300 come back with different pieces of the answer. because now you don’t have 300 agents. you have: 300 outputs → hundreds of sources → repeated entities → overlapping claims → contradictions → thousands of possible relationships and all of that has to collapse into one structure. that’s what the context graph is doing. instead of: agent → report you get: agents → sources → entities → edges → contradictions → verification → one graph every source becomes a node. every shared entity creates a connection. 300 agents can create information. the graph is what turns that information into memory the next agent can actually use. that’s the anatomy behind the setup ↓

Ricker

19,652 次观看 • 23 天前

Jev Founder, Diogo Almeida (ex-OpenAI): "The next era is not the Claude Code era. Claude Code is still part of the assistance era - Jev is the next step Jev is x200 faster, x400 cheaper and has 0 hallucination. This is what comes after RLHF" In 17 minutes he explains why every model you use has a human-shaped flaw baked into it and why Jev is better worth more than a $500 Claude Code engineering course watch today, then read how to actually boost yourself x100 with Jev in the post below
17:33

Jev Founder, Diogo Almeida (ex-OpenAI): "The next era is not the Claude Code era. Claude Code is still part of the assistance era - Jev is the next step Jev is x200 faster, x400 cheaper and has 0 hallucination. This is what comes after RLHF" In 17 minutes he explains why every model you use has a human-shaped flaw baked into it and why Jev is better worth more than a $500 Claude Code engineering course watch today, then read how to actually boost yourself x100 with Jev in the post below

Codez

191,889 次观看 • 9 天前

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.
0:20

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 次观看 • 28 天前

Ok this is actually insane. Everyone building agents right now is doing the same expensive mistake. They let the model decide LITERALLY everything. Every check. Every gate. Every "should this proceed." All routed through the same $50/M model that's supposed to be doing the hard thinking. That's not intelligence. That's just burning money to ask yes or no questions. Here's what Jev Engineering actually does: request → structured state → Jev router → cheapest capable model → worker → approval check → execution gate → tool The decision layer doesn't write a single word. It routes. Scores. Blocks. Approves. That's it. The expensive model only gets touched when the task LITERALLY requires reasoning. Everything else gets handled by something that costs almost nothing and responds in milliseconds. 193x faster. 444x cheaper. Not projected. Measured. Most people are going to keep paying frontier prices to ask their agent "yes or no" for another year before they figure this out. Full breakdown below, this is the unlock nobody's talking about yet. Follow CyrilXBT, I'm not gatekeeping this one.
0:40

Ok this is actually insane. Everyone building agents right now is doing the same expensive mistake. They let the model decide LITERALLY everything. Every check. Every gate. Every "should this proceed." All routed through the same $50/M model that's supposed to be doing the hard thinking. That's not intelligence. That's just burning money to ask yes or no questions. Here's what Jev Engineering actually does: request → structured state → Jev router → cheapest capable model → worker → approval check → execution gate → tool The decision layer doesn't write a single word. It routes. Scores. Blocks. Approves. That's it. The expensive model only gets touched when the task LITERALLY requires reasoning. Everything else gets handled by something that costs almost nothing and responds in milliseconds. 193x faster. 444x cheaper. Not projected. Measured. Most people are going to keep paying frontier prices to ask their agent "yes or no" for another year before they figure this out. Full breakdown below, this is the unlock nobody's talking about yet. Follow CyrilXBT, I'm not gatekeeping this one.

CyrilXBT

21,816 次观看 • 7 天前

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 ↓
1:55:41

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 次观看 • 21 天前

Loops vs. Graphs, clearly explained! loops are great, but they have a ceiling: a loop makes one unit of work better. it cannot decide which units exist. so you end up with a very good agent running the wrong three steps, in the wrong order, one at a time. Graph engineering fixes this by moving the decision up a layer: what runs, what runs at the same time, and what never runs at all. you need both. here's how it works: a graph splits your system into two kinds of decision. ↳ inside a unit: the loop. produce, check, correct, repeat until green ↳ between units: the graph. split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs you get parallel work, isolated contexts, and steps that stop running when nothing needs them. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. a graph where every edge is an agent pays rent on its own wiring. one thing to know before you scale it. a graph has two return paths, and almost everyone builds one. ↳ the correction edge is short. a gate rejects one unit back to the step that produced it, and it fixes the run you are in ↳ the learning edge is long. an accepted result goes back to the splitter as a constraint, and it fixes every run after skip the second and you get a graph that is fast and never gets smarter. next week it starts from the same place with the same blind spots. and a smaller one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓
0:41

Loops vs. Graphs, clearly explained! loops are great, but they have a ceiling: a loop makes one unit of work better. it cannot decide which units exist. so you end up with a very good agent running the wrong three steps, in the wrong order, one at a time. Graph engineering fixes this by moving the decision up a layer: what runs, what runs at the same time, and what never runs at all. you need both. here's how it works: a graph splits your system into two kinds of decision. ↳ inside a unit: the loop. produce, check, correct, repeat until green ↳ between units: the graph. split, fan out, merge, gate, send back Prompts → Context → Harness → Loops → Graphs you get parallel work, isolated contexts, and steps that stop running when nothing needs them. the trick is being selective about what becomes a node. only spend a model where judgment lives. merging, ranking, deduping and schema checks are edges, and edges are code. free, instant, and they cannot be argued out of a verdict. a graph where every edge is an agent pays rent on its own wiring. one thing to know before you scale it. a graph has two return paths, and almost everyone builds one. ↳ the correction edge is short. a gate rejects one unit back to the step that produced it, and it fixes the run you are in ↳ the learning edge is long. an accepted result goes back to the splitter as a constraint, and it fixes every run after skip the second and you get a graph that is fast and never gets smarter. next week it starts from the same place with the same blind spots. and a smaller one that eats whole nights: when a unit fails, return that unit, not the batch. send back four slices because one failed and you have just rewritten three correct ones. do it twice in a run and the run never converges. below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open. save this and read it below ↓

Hanako

73,867 次观看 • 1 个月前

Anthropic engineer: "At Anthropic, all of our engineers are running hundreds of agents The way you do it is graph engineering" In just 36 minutes, he shows how Anthropic runs hundreds of agents at once and what actually makes it possible Prompts → Agents → Loops → Graphs The part most people skip is the return path, where every accepted result becomes a constraint for the next run Same model, same tokens, completely different system Prompting is the old workflow Graph engineering is the next one Watch it today Then save the full graph engineering guide below before everyone starts catching up ↓
35:57

Anthropic engineer: "At Anthropic, all of our engineers are running hundreds of agents The way you do it is graph engineering" In just 36 minutes, he shows how Anthropic runs hundreds of agents at once and what actually makes it possible Prompts → Agents → Loops → Graphs The part most people skip is the return path, where every accepted result becomes a constraint for the next run Same model, same tokens, completely different system Prompting is the old workflow Graph engineering is the next one Watch it today Then save the full graph engineering guide below before everyone starts catching up ↓

Lunar

32,634 次观看 • 18 天前

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.
0:29

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 次观看 • 4 天前

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

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

Lunar

52,359 次观看 • 1 个月前

Google's team published a 9-page PDF on Harness Engineering. one formula replaced prompt engineering: Agent = Model + Harness the twist: same Claude Sonnet, same benchmark. change only the harness the playbook, six steps: step 1 -> add guides AGENTS.md, rule files, constraint docs. every line is a past agent failure turned into a permanent fix step 2 -> add sensors linters, tests, validation scripts the agent runs on its own output before a human sees it step 3 -> build the agentic loop plan, execute, verify, fix. bounded retries, budget caps, escalation when stuck step 4 -> externalize memory the model forgets every session. the harness holds state, decisions and artifacts across all of them step 5 -> enforce permissions which tools, how many writes, what needs approval. safety lives in the harness, never in the model step 6 -> wire observability track every tool call, cost and retry. trip wires fire when behavior drifts the result: your agent turns from a demo into infrastructure every failure makes the system permanently better, not just the next conversation that's also the line between an agent you show people and one a client pays you to leave running one harness gets you a reliable loop. connect several and it becomes graph engineering, where one agent's failure turns into another agent's sensor the PDF stops at the harness. the graph is the next layer that breakdown, running on Kimi, is below ↓
0:24

Google's team published a 9-page PDF on Harness Engineering. one formula replaced prompt engineering: Agent = Model + Harness the twist: same Claude Sonnet, same benchmark. change only the harness the playbook, six steps: step 1 -> add guides AGENTS.md, rule files, constraint docs. every line is a past agent failure turned into a permanent fix step 2 -> add sensors linters, tests, validation scripts the agent runs on its own output before a human sees it step 3 -> build the agentic loop plan, execute, verify, fix. bounded retries, budget caps, escalation when stuck step 4 -> externalize memory the model forgets every session. the harness holds state, decisions and artifacts across all of them step 5 -> enforce permissions which tools, how many writes, what needs approval. safety lives in the harness, never in the model step 6 -> wire observability track every tool call, cost and retry. trip wires fire when behavior drifts the result: your agent turns from a demo into infrastructure every failure makes the system permanently better, not just the next conversation that's also the line between an agent you show people and one a client pays you to leave running one harness gets you a reliable loop. connect several and it becomes graph engineering, where one agent's failure turns into another agent's sensor the PDF stops at the harness. the graph is the next layer that breakdown, running on Kimi, is below ↓

Annatar.md

78,774 次观看 • 20 天前

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
0:38

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 次观看 • 9 天前