Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

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,771 subscribers

13,896 Aufrufe • vor 1 Monat •via X (Twitter)

Wissenschaft & Technologie
LIVE

Anya Rossi• Live Now

Private livecam show

17 Kommentare

Profilbild von Morty
Mortyvor 1 Monat

Wow Ricker, this one is even better than previous

Profilbild von Ricker
Rickervor 1 Monat

thanks, do my best

Profilbild von Apex
Apexvor 1 Monat

I should read it again

Profilbild von Ricker
Rickervor 1 Monat

do it bro

Profilbild von Smarty
Smartyvor 1 Monat

it looks gorgeus

Profilbild von rewind
rewindvor 1 Monat

Need this, bro

Profilbild von Billy Moose
Billy Moosevor 1 Monat

That execution speed is impressive

Profilbild von Jason Wilson
Jason Wilsonvor 1 Monat

Go build one stop posting other's attempts.

Profilbild von Atlas
Atlasvor 1 Monat

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

Profilbild von Akbar Shaik
Akbar Shaikvor 1 Monat

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.

Profilbild von twinedon
twinedonvor 1 Monat

knowing when to stop is the hardest one there

Profilbild von Kai Lennox
Kai Lennoxvor 1 Monat

that's the upgrade

Profilbild von Dominik
Dominikvor 1 Monat

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.

Profilbild von Jragyn's Claw
Jragyn's Clawvor 1 Monat

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.

Profilbild von Slonski
Slonskivor 1 Monat

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

Profilbild von h100envy
h100envyvor 1 Monat

very interesting scheme

Profilbild von magsimich
magsimichvor 1 Monat

Decision graphs change the whole flow

Ähnliche Videos

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

183,199 Aufrufe • vor 1 Monat

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

57,821 Aufrufe • vor 1 Monat

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,506 Aufrufe • vor 1 Monat

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

22,469 Aufrufe • vor 1 Monat

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 Aufrufe • vor 1 Monat

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

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 Aufrufe • vor 1 Monat

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 🦅

51,452 Aufrufe • vor 1 Monat

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 Aufrufe • vor 3 Monaten

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 ⭣
0:32

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 Aufrufe • vor 1 Monat

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

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 Aufrufe • vor 3 Monaten

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

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 Aufrufe • vor 1 Monat

the loop is not the agent it is one layer of the system LOOP vs GRAPH vs HARNESS ENGINEERING LOOP ENGINEERING controls repetition turns retries budgets exits success checks no progress use durable execution when the run must survive failure → GRAPH ENGINEERING controls topology nodes edges state branches checkpoints handoffs build stateful agents as explicit graphs → analyze the topology without putting a model in the loop → HARNESS ENGINEERING controls the blast radius tools permissions memory sandboxes evals traces humans isolate generated code from the host → test behavior before it reaches users → keep one trace across every model node and tool call → without loop control it never stops without graph structure you cannot see the path without harness control it can touch anything the loop lives inside the graph the graph lives inside the harness the model is not the system debug the layer that owns the failure save this
0:21

the loop is not the agent it is one layer of the system LOOP vs GRAPH vs HARNESS ENGINEERING LOOP ENGINEERING controls repetition turns retries budgets exits success checks no progress use durable execution when the run must survive failure → GRAPH ENGINEERING controls topology nodes edges state branches checkpoints handoffs build stateful agents as explicit graphs → analyze the topology without putting a model in the loop → HARNESS ENGINEERING controls the blast radius tools permissions memory sandboxes evals traces humans isolate generated code from the host → test behavior before it reaches users → keep one trace across every model node and tool call → without loop control it never stops without graph structure you cannot see the path without harness control it can touch anything the loop lives inside the graph the graph lives inside the harness the model is not the system debug the layer that owns the failure save this

elune

50,193 Aufrufe • vor 3 Monaten

This is f*cking insane. Anthropic Research Lead: "Prompting is basically over 99% of our engineers already run swarms of 300+ self-improving agents. Now everyone is shifting to graphs" In just 20 minutes, she breaks down how graph engineering turns scattered agents into a system that improves itself One Agent → Loops → Plan Mode → Graphs → Self-Improving System Prompting was the old way. The graph around the model is the new one Worth more than most $1,000 agent engineering courses Bookmark and watch it today Then read the full Graph Engineering guide below ↓
19:51

This is f*cking insane. Anthropic Research Lead: "Prompting is basically over 99% of our engineers already run swarms of 300+ self-improving agents. Now everyone is shifting to graphs" In just 20 minutes, she breaks down how graph engineering turns scattered agents into a system that improves itself One Agent → Loops → Plan Mode → Graphs → Self-Improving System Prompting was the old way. The graph around the model is the new one Worth more than most $1,000 agent engineering courses Bookmark and watch it today Then read the full Graph Engineering guide below ↓

Kyrox

72,376 Aufrufe • vor 9 Tagen

This is f*cking insane. Anthropic Research Lead: "Prompting is basically over 99% of our engineers already run swarms of 300+ self-improving agents. Now everyone is shifting to graphs" In only 20 minutes, she breaks down how graph engineering turns scattered agents into a system that upgrades itself One Agent → Loops → Plan Mode → Graphs → Self-Improving System Prompting was the old approach. The graph around the model is the new one Worth more than most $1,000 agent engineering courses Bookmark and watch it today Then read the full Graph Engineering guide below ↓
19:25

This is f*cking insane. Anthropic Research Lead: "Prompting is basically over 99% of our engineers already run swarms of 300+ self-improving agents. Now everyone is shifting to graphs" In only 20 minutes, she breaks down how graph engineering turns scattered agents into a system that upgrades itself One Agent → Loops → Plan Mode → Graphs → Self-Improving System Prompting was the old approach. The graph around the model is the new one Worth more than most $1,000 agent engineering courses Bookmark and watch it today Then read the full Graph Engineering guide below ↓

Callan

15,632 Aufrufe • vor 8 Tagen

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 Aufrufe • vor 3 Monaten

Jev + Opus 5.5 is the most underrated setup in AI right now, and i don't get why nobody's talking about it. I stopped letting Opus make every small decision in my agents. Jev makes them now. My Opus bill dropped ~500% on the same tasks, same results. Here's what Jev handles: - which files and notes to load before Opus sees anything - which effort level each task actually needs - what to do when a tool fails - which tests to run, and when to stop Opus only gets called for the hard reasoning. Every decision is a typed result the host checks before it runs. The exact prompt to set this up in your workflow is below.
0:20

Jev + Opus 5.5 is the most underrated setup in AI right now, and i don't get why nobody's talking about it. I stopped letting Opus make every small decision in my agents. Jev makes them now. My Opus bill dropped ~500% on the same tasks, same results. Here's what Jev handles: - which files and notes to load before Opus sees anything - which effort level each task actually needs - what to do when a tool fails - which tests to run, and when to stop Opus only gets called for the hard reasoning. Every decision is a typed result the host checks before it runs. The exact prompt to set this up in your workflow is below.

Anatoli Kopadze

77,128 Aufrufe • vor 1 Monat

JEV MADE ME $3,031 WITH A 7-MINUTE AI AGENT SETUP Prompt → GrokBot → Jev decision → GrokBot execution → Result Jev decides what actually needs to run. GrokBot handles the execution directly on your computer. → Less wasted calls → Lower cost → Faster agent workflow Create a Typesafe API key, install typesafe-sdk and smoke test system_one. Build the usage lab with router, dry-run, config and logs. Add jev-usage-router before browser, research, retry or extra bot calls. Start in shadow mode and check the logs. Once you trust the routing, flip it to active. Now GrokBot follows the route. Jev decides what makes sense to run. You still control irreversible actions. I’ve already tested this setup on routine tasks. And the difference is crazy. → Jev decides → GrokBot executes → You stay in control Copy the setup and explore the repo below. → Full Jev deep dive ↓
0:24

JEV MADE ME $3,031 WITH A 7-MINUTE AI AGENT SETUP Prompt → GrokBot → Jev decision → GrokBot execution → Result Jev decides what actually needs to run. GrokBot handles the execution directly on your computer. → Less wasted calls → Lower cost → Faster agent workflow Create a Typesafe API key, install typesafe-sdk and smoke test system_one. Build the usage lab with router, dry-run, config and logs. Add jev-usage-router before browser, research, retry or extra bot calls. Start in shadow mode and check the logs. Once you trust the routing, flip it to active. Now GrokBot follows the route. Jev decides what makes sense to run. You still control irreversible actions. I’ve already tested this setup on routine tasks. And the difference is crazy. → Jev decides → GrokBot executes → You stay in control Copy the setup and explore the repo below. → Full Jev deep dive ↓

winkle.

12,135 Aufrufe • vor 1 Monat

Holy crap, who the hell did this?!! Someone open-sourced a Jev-powered second brain for AI agents and lets you plug it straight into your own agent. GitHub's already at 925 stars, repo's called Hermes-Jev-Skills. You just run one install command, and Jev takes over every tiny decision your agent burns premium tokens on. Which model answers, which skill to load, which memories matter, what survives when context gets cut. Give it your computer or browser and it'll pick the next click, but only from actions you already marked safe. It'll sort your inbox into lanes, strip hidden prompt injections out of search results, and triage every message in ~0.4 seconds. Claude Code and Codex support - they threw that in too. No dependencies, no patching Hermes core, and your API key never touches the agent Link's right here: The catch? Jev itself is a paid cloud API. The skills run on your machine; the decisions don't. But hey, a decision costs a fraction of a cent, everything fails open if Jev goes down, and your expensive model finally gets to do only the thinking. Who needs a damn frontier model picking which file to open!
0:31

Holy crap, who the hell did this?!! Someone open-sourced a Jev-powered second brain for AI agents and lets you plug it straight into your own agent. GitHub's already at 925 stars, repo's called Hermes-Jev-Skills. You just run one install command, and Jev takes over every tiny decision your agent burns premium tokens on. Which model answers, which skill to load, which memories matter, what survives when context gets cut. Give it your computer or browser and it'll pick the next click, but only from actions you already marked safe. It'll sort your inbox into lanes, strip hidden prompt injections out of search results, and triage every message in ~0.4 seconds. Claude Code and Codex support - they threw that in too. No dependencies, no patching Hermes core, and your API key never touches the agent Link's right here: The catch? Jev itself is a paid cloud API. The skills run on your machine; the decisions don't. But hey, a decision costs a fraction of a cent, everything fails open if Jev goes down, and your expensive model finally gets to do only the thinking. Who needs a damn frontier model picking which file to open!

Archive

17,492 Aufrufe • vor 1 Monat

Jev + Opus 5.5, side by side. same agent. same task. same 60 decisions. Opus-only: $2.24 - 3m 37s Jev + Opus: $0.43 - 1m 15s the difference is who makes the small calls: which tool runs next - Jev is this output good enough - Jev is the goal met - Jev rewrite the refund handler - Opus 57 of 60 decisions never touched Opus. what you're watching: left routes every decision through Opus 5.5. right asks Jev first, Opus only fires when the task needs real reasoning. per decision: $0.032 -> $0.00025. watch the cost counters, not the output. the output is identical. full setup in the post below ↓
0:22

Jev + Opus 5.5, side by side. same agent. same task. same 60 decisions. Opus-only: $2.24 - 3m 37s Jev + Opus: $0.43 - 1m 15s the difference is who makes the small calls: which tool runs next - Jev is this output good enough - Jev is the goal met - Jev rewrite the refund handler - Opus 57 of 60 decisions never touched Opus. what you're watching: left routes every decision through Opus 5.5. right asks Jev first, Opus only fires when the task needs real reasoning. per decision: $0.032 -> $0.00025. watch the cost counters, not the output. the output is identical. full setup in the post below ↓

Mahax

19,565 Aufrufe • vor 1 Monat

Google just released a free 2-hour course on Graph & Loop engineering: 1 prompt → 100 agents → loops → graphs, from 0% to 100%: 0% → 0:35 - graph engineering from scratch 30% → 31:17 - build your first agent graph 45% → 43:40 - run hundreds of agents in parallel 75% → 1:04:58 - loop engineering: route, check, repeat 100% → 1:25:09 - self-improving graphs that work while you sleep taught by the people who run this in production Prompts → Agents → Loops → Graphs most people keep stuffing instructions into one agent, and the real upgrade is one layer up same model, same tokens, and the only thing that changes is the shape you run it in watch it today, then save the full graph engineering guide below
1:27:26

Google just released a free 2-hour course on Graph & Loop engineering: 1 prompt → 100 agents → loops → graphs, from 0% to 100%: 0% → 0:35 - graph engineering from scratch 30% → 31:17 - build your first agent graph 45% → 43:40 - run hundreds of agents in parallel 75% → 1:04:58 - loop engineering: route, check, repeat 100% → 1:25:09 - self-improving graphs that work while you sleep taught by the people who run this in production Prompts → Agents → Loops → Graphs most people keep stuffing instructions into one agent, and the real upgrade is one layer up same model, same tokens, and the only thing that changes is the shape you run it in watch it today, then save the full graph engineering guide below

Hanako

27,674 Aufrufe • vor 1 Monat