Video yükleniyor...

Video Yüklenemedi

Bu video yüklenirken bir sorun oluştu. Bu geçici bir ağ sorunundan kaynaklanıyor olabilir veya video kullanılamıyor olabilir.

Ana Sayfaya Dön

Another insane Jev use case! Decision models like Jev are making it dramatically cheaper to evaluate what actually happens inside an agent run. And now there’s an open-source memory layer that puts those evaluations to work, making useful lessons reusable across 20+ agent harnesses: - Claude Code - Codex... - Cursor - OpenCode - and more. The project is Beacon, from Asymptote Labs. GitHub: (don't forget to star 🌟) Here’s what I did in the video below. 1) I gave Claude Code a coding task. It made changes and ran tests while Beacon automatically recorded the session. 2) I had Jev evaluate the run. The first evaluation returned review because I hadn’t provided a correction, so my app saved nothing. 3) I corrected the agent, and it updated its work and reran the tests. Jev evaluated the updated session, and this time the results met my app’s rules for saving a memory. 4) I saved the correction and its supporting evidence as shared memory. Then I opened a separate Codex session and explicitly asked it to read that memory. Codex recalled the correction from the earlier Claude Code session without me having to explain it again. Beacon captured the session history. Jev evaluated what was worth keeping, while my app applied the storage rules and saved the lesson. That correction was now available as context outside the conversation where I first made it. I cover this build in more detail in the video with Justin, co-founder of Asymptote Labs, alongside moving sessions between agents, creating reusable skills, and detecting security risks across agent activity. Watch the full video below.show more

Akshay 🚀

292,084 subscribers

30,088 görüntüleme • 15 gün önce •via X (Twitter)

Bilim & Teknoloji Eğitim

Anya Rossi• Live Now

Private livecam show

21 Yorum

stunspot | ⟨🤩⨯📍⟩ | profil fotoğrafı

stunspot | ⟨🤩⨯📍⟩ |14 gün önce

It's... not all that... "insane", man. Set up "memory" (ie "note taking") system. Use decision model to decide if memory should be comitted. Format it sensibly so other shit can read it. I mean, ok, smart enough design, I spose, but what's the revolutionary part?

Jaydeep profil fotoğrafı

Jaydeep14 gün önce

Watched this video, excellent usecase and super cool demo that @jqdsouza

Akshay 🚀 profil fotoğrafı

Akshay 🚀14 gün önce

@jqdsouza Glad you found it helpful Jaydeep!

Khairallah AL-Awady profil fotoğrafı

Khairallah AL-Awady15 gün önce

great breakdown Akshay!

OnFinality profil fotoğrafı

OnFinality14 gün önce

The silo problem is real, but shared memory across Cursor, Claude Code, and Codex gets messy fast once the same lesson conflicts between runs. Curious how you handle dedup and staleness, or does it just append and let retrieval sort it out?

Jean Vargas profil fotoğrafı

Jean Vargas15 gün önce

reusing lessons from evaluated runs makes a lot of sense. how does it decide a lesson is worth keeping? one bad run, or only after the same failure shows up a few times?

Shanto Mathew | AI Builder profil fotoğrafı

Shanto Mathew | AI Builder15 gün önce

cheap grading on every run is the part i care about. memory without a grader just saves confident mistakes for later

Nexqor profil fotoğrafı

Nexqor15 gün önce

beacon handles state, that's the whole story

Dominik profil fotoğrafı

Dominik14 gün önce

memory that outlives the harness it was learned in feels like the real unlock for coding agents

Rehman Ahmad profil fotoğrafı

Rehman Ahmad15 gün önce

This is the missing piece. Agents forgetting everything between runs is why they repeat the same mistakes. A shared memory layer means one agent's hard lesson helps all of them. The Codex reusing Claude Code's correction was the coolest part.

Rohan Bhanot profil fotoğrafı

Rohan Bhanot15 gün önce

storing lessons from evals instead of raw transcripts is the right call imo. raw chat logs as memory just turn into noise after a week

安叫兽|Bird🕊️ 🔶 BNB profil fotoğrafı

安叫兽|Bird🕊️ 🔶 BNB14 gün önce

就怕把踩过的坑也当经验传下去了

Giuliano profil fotoğrafı

Giuliano14 gün önce

This a Goldmine Workflow Cheers for sharing this Akshay bro

Ao Fu profil fotoğrafı

Ao Fu14 gün önce

cheaper to evaluate runs is great. what scores the evaluator when the agent's own report of the run is wrong?

George Cooper profil fotoğrafı

George Cooper14 gün önce

Savage! This Jev thing is getting wild, making evaluation of agent runs super cheap and reproducible.

PuneetSingh⚡️ profil fotoğrafı

PuneetSingh⚡️15 gün önce

Before a lesson goes into shared memory, save where it came from and the date with it. When an old correction later steers an agent the wrong way, you can find it and delete it in a minute instead of guessing which past session taught that habit.

Kai Lennox profil fotoğrafı

Kai Lennox15 gün önce

Wait, so I can correct Claude once and Codex won't make the same mistake? I need this lol

三分钟懂行 profil fotoğrafı

三分钟懂行15 gün önce

把纠正和依据一起留下，换个工具时再明确让它读，比重新讲一遍来龙去脉省事多了。

Caviar profil fotoğrafı

Caviar14 gün önce

Можешь более понятно объяснить суть

catman profil fotoğrafı

catman14 gün önce

Agent memory becomes useful when corrections are evaluated against evidence, then saved in a form another harness can actually retrieve and apply.

Ship the Agent profil fotoğrafı

Ship the Agent14 gün önce

the eval is the easy part now. the reusable-memory-across-20-agents part is where it gets interesting. does it log which lesson came from which run, or is it just a blob you trust?

Benzer Videolar

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

293,860 görüntüleme • 1 ay önce

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 🚀

121,058 görüntüleme • 1 ay önce

Another insane way to use Jev: Jev makes it dramatically cheaper to identify which corrections and trajectories from an agent run are reusable across agents. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode - Hermes, and 20+ more Beacon by Asymptote Labs continuously captures agent sessions across harnesses and stores their traces in a shared index. I used it with Jev to build a live cross-agent memory workflow. Beacon captures each run as it happens across all harnesses on my machine. Then Jev evaluates whether the trace contains a reusable engineering lesson, and the approved lesson becomes available to the next agent. GitHub repo: (don't forget to star it ⭐) Preserving an agent run and learning from it are two different problems. Most traces contain file reads, failed commands, routine exploration, and implementation details that only apply to one task. Passing the complete transcript to another agent adds context without identifying what matters. In this workflow, one agent never receives another agent's raw transcript. It receives only the specific engineering lesson produced from the evaluated trace. A correction made in one agent can then prevent the same mistake when another agent encounters a similar problem. The recording shows the complete workflow I built. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Another insane way to use Jev: Jev makes it dramatically cheaper to identify which corrections and trajectories from an agent run are reusable across agents. And finally, someone open-sourced a self-improving memory layer that can put that signal to work across agent harnesses: - Claude Code - Codex - Cursor - OpenCode - Hermes, and 20+ more Beacon by Asymptote Labs continuously captures agent sessions across harnesses and stores their traces in a shared index. I used it with Jev to build a live cross-agent memory workflow. Beacon captures each run as it happens across all harnesses on my machine. Then Jev evaluates whether the trace contains a reusable engineering lesson, and the approved lesson becomes available to the next agent. GitHub repo: (don't forget to star it ⭐) Preserving an agent run and learning from it are two different problems. Most traces contain file reads, failed commands, routine exploration, and implementation details that only apply to one task. Passing the complete transcript to another agent adds context without identifying what matters. In this workflow, one agent never receives another agent's raw transcript. It receives only the specific engineering lesson produced from the evaluated trace. A correction made in one agent can then prevent the same mistake when another agent encounters a similar problem. The recording shows the complete workflow I built. If you want to dive deeper into Jev, I also wrote a hands-on guide to building this Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

70,794 görüntüleme • 16 gün önce

I gave Claude Code, Codex, and Cursor a self-improving, shared MEMORY. Now my coding agents learn from each other, and their knowledge follows me wherever I work. Coding agents work in silos. Your corrections in Cursor don't carry over to Claude Code, and skills built in Codex don't automatically transfer to other harnesses. So switching tools often means starting from scratch. What if every coding agent could learn from everything you've already done? I invited Justin D'Souza, co-founder of Asymptote Labs, to show me how to make this possible with Beacon, a 100% open-source memory layer for coding agents. We set it up live, explored real coding sessions, and watched Beacon turn past work into reusable knowledge. Here's what I learned: 1. One memory layer for 20+ coding agents. Beacon captures activity across Claude Code, Cursor, Codex, and 20+ harnesses using OpenTelemetry, hooks, and local session files. Everything gets normalized into a single format, regardless of which agent you're using. 2. Your entire coding history becomes searchable. Every prompt, tool call, command, file change, and response is captured in a structured trace. Instead of losing valuable context when a session ends, you build a searchable history of everything your agents have done. 3. Switch agents without starting over. Hit your usage limit in Cursor? Open Claude Code and ask it to continue your latest Cursor session. Beacon retrieves the relevant context in milliseconds so your next agent can pick up where the last one left off. 4. Your agents learn from your past work. This is where things get interesting. Beacon identifies repeated workflows and turns them into reusable skills. In our demo, it discovered a recurring UI development workflow and generated a skill containing the exact dev server commands, screenshot steps, and deployment instructions. You teach one agent something once. Every other agent can benefit. 5. Stop accumulating skills nobody uses. Have 100 skills but only use five? Beacon analyzes actual usage across thousands of sessions and identifies skills worth keeping, combining, or removing. Your agent's memory gets more useful, not just bigger. 6. Security rules that follow you across every harness. Beacon includes hundreds of detection rules that work across agents. It can identify risky behavior, including sequences where an agent reads sensitive credentials and then makes an outbound network request. 7. It even caught a real credential leak. While reviewing Justin's actual Cursor history, Beacon surfaced an incident where part of a production database password had been sent to a model provider. That's the power of having visibility into what your agents are actually doing. 8. One prompt to get started. Completely open source. Paste a setup prompt into your coding agent and you're off. Keep everything local on your machine, or use Beacon Cloud for free. If you're juggling multiple coding agents, you need to check this out. Drop a like and share it with someone facing the same issue. Beacon on GitHub: (don't forget to star 🌟) Enjoy the episode. Cheers!

I gave Claude Code, Codex, and Cursor a self-improving, shared MEMORY. Now my coding agents learn from each other, and their knowledge follows me wherever I work. Coding agents work in silos. Your corrections in Cursor don't carry over to Claude Code, and skills built in Codex don't automatically transfer to other harnesses. So switching tools often means starting from scratch. What if every coding agent could learn from everything you've already done? I invited Justin D'Souza, co-founder of Asymptote Labs, to show me how to make this possible with Beacon, a 100% open-source memory layer for coding agents. We set it up live, explored real coding sessions, and watched Beacon turn past work into reusable knowledge. Here's what I learned: 1. One memory layer for 20+ coding agents. Beacon captures activity across Claude Code, Cursor, Codex, and 20+ harnesses using OpenTelemetry, hooks, and local session files. Everything gets normalized into a single format, regardless of which agent you're using. 2. Your entire coding history becomes searchable. Every prompt, tool call, command, file change, and response is captured in a structured trace. Instead of losing valuable context when a session ends, you build a searchable history of everything your agents have done. 3. Switch agents without starting over. Hit your usage limit in Cursor? Open Claude Code and ask it to continue your latest Cursor session. Beacon retrieves the relevant context in milliseconds so your next agent can pick up where the last one left off. 4. Your agents learn from your past work. This is where things get interesting. Beacon identifies repeated workflows and turns them into reusable skills. In our demo, it discovered a recurring UI development workflow and generated a skill containing the exact dev server commands, screenshot steps, and deployment instructions. You teach one agent something once. Every other agent can benefit. 5. Stop accumulating skills nobody uses. Have 100 skills but only use five? Beacon analyzes actual usage across thousands of sessions and identifies skills worth keeping, combining, or removing. Your agent's memory gets more useful, not just bigger. 6. Security rules that follow you across every harness. Beacon includes hundreds of detection rules that work across agents. It can identify risky behavior, including sequences where an agent reads sensitive credentials and then makes an outbound network request. 7. It even caught a real credential leak. While reviewing Justin's actual Cursor history, Beacon surfaced an incident where part of a production database password had been sent to a model provider. That's the power of having visibility into what your agents are actually doing. 8. One prompt to get started. Completely open source. Paste a setup prompt into your coding agent and you're off. Keep everything local on your machine, or use Beacon Cloud for free. If you're juggling multiple coding agents, you need to check this out. Drop a like and share it with someone facing the same issue. Beacon on GitHub: (don't forget to star 🌟) Enjoy the episode. Cheers!

Akshay 🚀

54,039 görüntüleme • 17 gün önce

Finally, an OpenRouter for agent harnesses! (including System One by Jev) Devs just open-sourced a plug-and-play infrastructure layer that lets you run any harness under a single interface, like: - Codex - Hermes - Claude code - DeepSeek Harness - System One, powered by Jev - And 9 more agent harnesses This means you can bring Jev into the same product that already uses Codex, Claude Code, or another supported harness, without writing another implementation for sessions, streaming, files, cancellation, and failure handling. Here's the repo: (don't forget to star it ⭐ ) The harnesses run locally, and the Unified Harness Protocol (UHP) defines the common task interface with an OpenAI Responses-compatible API. If you want to dive deeper, my recent article explains why model routing is not the same as harness routing, and what it takes to support multiple harnesses. It also covers UHP, the full local setup, a working API call, and how sessions and files work. Read it below.

Finally, an OpenRouter for agent harnesses! (including System One by Jev) Devs just open-sourced a plug-and-play infrastructure layer that lets you run any harness under a single interface, like: - Codex - Hermes - Claude code - DeepSeek Harness - System One, powered by Jev - And 9 more agent harnesses This means you can bring Jev into the same product that already uses Codex, Claude Code, or another supported harness, without writing another implementation for sessions, streaming, files, cancellation, and failure handling. Here's the repo: (don't forget to star it ⭐ ) The harnesses run locally, and the Unified Harness Protocol (UHP) defines the common task interface with an OpenAI Responses-compatible API. If you want to dive deeper, my recent article explains why model routing is not the same as harness routing, and what it takes to support multiple harnesses. It also covers UHP, the full local setup, a working API call, and how sessions and files work. Read it below.

Akshay 🚀

361,933 görüntüleme • 1 ay önce

Quick demo of how I use session to session messaging in Claude Code + Ghostty (Save this and try it in your own workflows) 1- I always start with a regular session and a panel running claude agents 2- The first session becomes the orchestrator. It creates the initial context, then distributes the work across other sessions using forks 3- Each fork starts with that context + a prompt telling it what to work on 4- I rename each session with ctrl + r to keep things organized and make it easy to message them from the main session 5- Using @ I send messages to the sessions that are running and ask them to report their task status back, so the main session always knows what everyone is working on This way, I only need 2 or 3 panels open and can switch between tasks as needed The days of opening endless terminal panels and running Claude Code 100 times just to look productive are over! What we need now is ORCHESTATION one main session coordinating everything through session messaging + Agent View And the key is context, build it in the main session first, then fork from there That’s what makes the entire workflow click

Quick demo of how I use session to session messaging in Claude Code + Ghostty (Save this and try it in your own workflows) 1- I always start with a regular session and a panel running claude agents 2- The first session becomes the orchestrator. It creates the initial context, then distributes the work across other sessions using forks 3- Each fork starts with that context + a prompt telling it what to work on 4- I rename each session with ctrl + r to keep things organized and make it easy to message them from the main session 5- Using @ I send messages to the sessions that are running and ask them to report their task status back, so the main session always knows what everyone is working on This way, I only need 2 or 3 panels open and can switch between tasks as needed The days of opening endless terminal panels and running Claude Code 100 times just to look productive are over! What we need now is ORCHESTATION one main session coordinating everything through session messaging + Agent View And the key is context, build it in the main session first, then fork from there That’s what makes the entire workflow click

Daniel San

63,748 görüntüleme • 2 ay önce

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

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

rody

47,630 görüntüleme • 1 ay önce

Finally, an OpenRouter for agent harnesses! (including System One by Jev) Devs just open-sourced plug-and-play infrastructure layer that lets you run any harness under a single interface for free, like: - Codex - Claude code - Hermes - DeepSeek Harness - System One, powered by Jev - And 9 more agent harnesses This means you can bring Jev into the same product that already uses Codex, Claude Code, or another supported harness, without writing another implementation for sessions, streaming, files, cancellation, and failure handling. Here's the repo: The harnesses run locally, and the Unified Harness Protocol (UHP) defines the common task interface with an OpenAI Responses-compatible API. If you want to dive deeper, the article below explains how to set up Jev from scratch, check it out ↓

Finally, an OpenRouter for agent harnesses! (including System One by Jev) Devs just open-sourced plug-and-play infrastructure layer that lets you run any harness under a single interface for free, like: - Codex - Claude code - Hermes - DeepSeek Harness - System One, powered by Jev - And 9 more agent harnesses This means you can bring Jev into the same product that already uses Codex, Claude Code, or another supported harness, without writing another implementation for sessions, streaming, files, cancellation, and failure handling. Here's the repo: The harnesses run locally, and the Unified Harness Protocol (UHP) defines the common task interface with an OpenAI Responses-compatible API. If you want to dive deeper, the article below explains how to set up Jev from scratch, check it out ↓

rody

88,298 görüntüleme • 1 ay önce

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

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

Noisy

13,407 görüntüleme • 1 ay önce

Glen is building the organizational learning and context layer for agents. Every agent session your team runs produces reasoning worth keeping, and nearly all of it is discarded the moment the window closes. Glen is the layer that unifies every agent and model your company run. Glen pulls in agent sessions from Claude Code, Codex and Cursor, plus Slack messages, GitHub prs, tickets, docs and calls. When a new agent picks up a task, Glen finds relevant prior context and injects it in the agents context window to steer it, producing knowledge work that is significantly higher quality, faster and cheaper than ever before. 29% less context and 21% faster to be exact. And Glen does more... > query the original agent behind any line of code > search every session your org has ever run > dynamic skill distillation > multiplayer agents > unified transcripts you can hand between Claude Code, Codex, and Cursor mid-task, > a company brain in Slack. Glen is in early access, sign up for the waitlist below.

Glen is building the organizational learning and context layer for agents. Every agent session your team runs produces reasoning worth keeping, and nearly all of it is discarded the moment the window closes. Glen is the layer that unifies every agent and model your company run. Glen pulls in agent sessions from Claude Code, Codex and Cursor, plus Slack messages, GitHub prs, tickets, docs and calls. When a new agent picks up a task, Glen finds relevant prior context and injects it in the agents context window to steer it, producing knowledge work that is significantly higher quality, faster and cheaper than ever before. 29% less context and 21% faster to be exact. And Glen does more... > query the original agent behind any line of code > search every session your org has ever run > dynamic skill distillation > multiplayer agents > unified transcripts you can hand between Claude Code, Codex, and Cursor mid-task, > a company brain in Slack. Glen is in early access, sign up for the waitlist below.

Nikos

20,626 görüntüleme • 2 ay önce

I couldn't f*cking believe this Stanford AI research team gave Claude Code a human brain setup. JEV is the fast gut brain. It scans everything in milliseconds and makes the easy calls. Claude is the slow thinking brain. It only wakes up for the hard ones. Here are the commands that wire the two together: /plugin marketplace add rashedInt32/jev-mcp /plugin install jev@jev-mcp -> Claude gets Jev as tools: classify, score, check npm install -g @dzhng/jevgrep jg "how are payments retried?" ./my-project -> ask what the code does, get the right files back. the author measured ~30% lower cost on the same tasks npx skills add altryne/jevify --skill jevify -> teaches your agent to hand the bulk yes/no work to Jev on its own > and fast-jev-compaction swaps Claude Code's summary for Jev decisions: it drops stale tool calls and keeps everything else word for word. Faster runs, smaller bills, barely any compute wasted. Save this before your next session.

I couldn't f*cking believe this Stanford AI research team gave Claude Code a human brain setup. JEV is the fast gut brain. It scans everything in milliseconds and makes the easy calls. Claude is the slow thinking brain. It only wakes up for the hard ones. Here are the commands that wire the two together: /plugin marketplace add rashedInt32/jev-mcp /plugin install jev@jev-mcp -> Claude gets Jev as tools: classify, score, check npm install -g @dzhng/jevgrep jg "how are payments retried?" ./my-project -> ask what the code does, get the right files back. the author measured ~30% lower cost on the same tasks npx skills add altryne/jevify --skill jevify -> teaches your agent to hand the bulk yes/no work to Jev on its own > and fast-jev-compaction swaps Claude Code's summary for Jev decisions: it drops stale tool calls and keeps everything else word for word. Faster runs, smaller bills, barely any compute wasted. Save this before your next session.

kiosa

86,755 görüntüleme • 26 gün önce

Insane Grok Grok Bot upgrade! Finally, you can connect Grok Bot to different agent harnesses and run tasks through their native runtimes. Devs just open-sourced HarnessRouter, the infrastructure layer that lets Grok Bot run tasks across: - Codex - Hermes - Claude Code - DeepSeek Harness - System One, powered by Jev - Pi, and 20 more GitHub repo: (don’t forget to star it ⭐) With HarnessRouter, each external specialist gets to use its own harness, model, tools, skills, and agent loop while Grok coordinates the project from one conversation. I tested this by asking Grok Bot to turn a support-ticket CSV into an interactive dashboard. Grok Bot assigned the analysis to DeepSeek Harness with Claude Sonnet 5.5, passed the output to Codex with GPT-5.5, and checked the finished dashboard in its browser. This differs from simply creating more Bots. These workers are not additional Grok Bots, and Grok Bot itself does not switch harnesses. Instead, it remains the coordinator while the delegated tasks run inside separate HarnessRouter sessions with the harness of your choice. So for another task, you can use Claude Code, Hermes, Pi, etc., without requiring a separate integration for task execution, sessions, streaming, and generated files. HarnessRouter standardizes all those operations through the Unified Harness Protocol (UHP). UHP handles sessions, streaming, files, cancellation, and failures through the same interface, regardless of which harness runs the task. I shared the GitHub repo above. And if you want to dive deeper into Grok Bot, I wrote about it in full in a masterclass, including the shared computer, memory, skills, routines, and the macOS setup. Read it below.

Insane Grok Grok Bot upgrade! Finally, you can connect Grok Bot to different agent harnesses and run tasks through their native runtimes. Devs just open-sourced HarnessRouter, the infrastructure layer that lets Grok Bot run tasks across: - Codex - Hermes - Claude Code - DeepSeek Harness - System One, powered by Jev - Pi, and 20 more GitHub repo: (don’t forget to star it ⭐) With HarnessRouter, each external specialist gets to use its own harness, model, tools, skills, and agent loop while Grok coordinates the project from one conversation. I tested this by asking Grok Bot to turn a support-ticket CSV into an interactive dashboard. Grok Bot assigned the analysis to DeepSeek Harness with Claude Sonnet 5.5, passed the output to Codex with GPT-5.5, and checked the finished dashboard in its browser. This differs from simply creating more Bots. These workers are not additional Grok Bots, and Grok Bot itself does not switch harnesses. Instead, it remains the coordinator while the delegated tasks run inside separate HarnessRouter sessions with the harness of your choice. So for another task, you can use Claude Code, Hermes, Pi, etc., without requiring a separate integration for task execution, sessions, streaming, and generated files. HarnessRouter standardizes all those operations through the Unified Harness Protocol (UHP). UHP handles sessions, streaming, files, cancellation, and failures through the same interface, regardless of which harness runs the task. I shared the GitHub repo above. And if you want to dive deeper into Grok Bot, I wrote about it in full in a masterclass, including the shared computer, memory, skills, routines, and the macOS setup. Read it below.

Avi Chawla

137,148 görüntüleme • 13 gün önce

Finally, an open-source runtime security layer for your agent harnesses. AI agents can call tools, run shell commands, modify files, and interact with production systems. But when something goes wrong, teams often have to reconstruct what the agent actually did from scattered logs after the fact. Agent Beacon is built to change that. It runs locally and records agent activity as it happens, including: → Tool calls → Shell commands → File changes → Approval decisions → Session and harness context The useful part is that it normalizes all of this into the same event format across 23+ agent harnesses. So instead of writing different detection logic for Claude Code, Codex, or another harness, security teams can reason about the underlying action itself. A command executed is a command executed, regardless of which harness produced it. Beacon also records how confidently an event was captured. An action can be directly observed from the runtime or inferred from indirect evidence. That matters when you start writing security rules against this data. For example, you can detect when an agent reads an environment variable, modifies a sensitive file, executes a suspicious command, or performs an action without the expected approval. And the detection happens while the session is still unfolding, not days later during incident reconstruction. Everything runs locally by default. You can inspect sessions through the dashboard, write your own detection rules, or forward the same normalized events to tools like Splunk, Datadog, Elastic, Sentinel, or CrowdStrike. Beacon GitHub: (don't forget to star 🌟) I also wrote a detailed article on the same, covering how important runtime security is and how to build it for your agent harnesses. The article is quoted below.

Finally, an open-source runtime security layer for your agent harnesses. AI agents can call tools, run shell commands, modify files, and interact with production systems. But when something goes wrong, teams often have to reconstruct what the agent actually did from scattered logs after the fact. Agent Beacon is built to change that. It runs locally and records agent activity as it happens, including: → Tool calls → Shell commands → File changes → Approval decisions → Session and harness context The useful part is that it normalizes all of this into the same event format across 23+ agent harnesses. So instead of writing different detection logic for Claude Code, Codex, or another harness, security teams can reason about the underlying action itself. A command executed is a command executed, regardless of which harness produced it. Beacon also records how confidently an event was captured. An action can be directly observed from the runtime or inferred from indirect evidence. That matters when you start writing security rules against this data. For example, you can detect when an agent reads an environment variable, modifies a sensitive file, executes a suspicious command, or performs an action without the expected approval. And the detection happens while the session is still unfolding, not days later during incident reconstruction. Everything runs locally by default. You can inspect sessions through the dashboard, write your own detection rules, or forward the same normalized events to tools like Splunk, Datadog, Elastic, Sentinel, or CrowdStrike. Beacon GitHub: (don't forget to star 🌟) I also wrote a detailed article on the same, covering how important runtime security is and how to build it for your agent harnesses. The article is quoted below.

Akshay 🚀

27,859 görüntüleme • 1 ay önce

this is pure f*cking gold for anyone running coding agents Jev founder Diogo Amogo wrote a PDF on building a Jev harness what their tests show: > up to 200x faster > up to 400x cheaper the model hasn't been the bottleneck for a while speed and cost both come from the harness you wrap around it • how to use it > give this PDF and the article below to Claude Code or Codex > ask it to rebuild its own setup around Jev • how it turns into a promotion > pick the agent workflow your team pays the most for > rebuild it in one evening > bring the before and after bill to your manager one evening of Jev engineering, and next week you're the one running a harness most teams haven't built yet

this is pure f*cking gold for anyone running coding agents Jev founder Diogo Amogo wrote a PDF on building a Jev harness what their tests show: > up to 200x faster > up to 400x cheaper the model hasn't been the bottleneck for a while speed and cost both come from the harness you wrap around it • how to use it > give this PDF and the article below to Claude Code or Codex > ask it to rebuild its own setup around Jev • how it turns into a promotion > pick the agent workflow your team pays the most for > rebuild it in one evening > bring the before and after bill to your manager one evening of Jev engineering, and next week you're the one running a harness most teams haven't built yet

Annatar.md

73,481 görüntüleme • 27 gün önce

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

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

193,792 görüntüleme • 1 ay önce

Our open-source devtool is trending #1 on Product Hunt! Beacon is self-improving memory for coding agents. 🫶 I’d love your support: → Turn past debugging sessions into reusable skills → Share learnings across Claude Code, Cursor, Codex, and 20+ harnesses → Search and replay past sessions → Stop wasting tokens rediscovering solutions → Build a feedback loop that makes your agents better over time → Free, open source, and local-first We built Beacon because we were tired of teaching our agents the same things over and over, only for them to start from zero every new session. Every agent session should make the next one smarter. ⭐️ Star us on GitHub:

Our open-source devtool is trending #1 on Product Hunt! Beacon is self-improving memory for coding agents. 🫶 I’d love your support: → Turn past debugging sessions into reusable skills → Share learnings across Claude Code, Cursor, Codex, and 20+ harnesses → Search and replay past sessions → Stop wasting tokens rediscovering solutions → Build a feedback loop that makes your agents better over time → Free, open source, and local-first We built Beacon because we were tired of teaching our agents the same things over and over, only for them to start from zero every new session. Every agent session should make the next one smarter. ⭐️ Star us on GitHub:

Justin D'Souza

529,126 görüntüleme • 4 gün önce

We’re betting our $5.5M seed round that the next leap in AI coding won’t come from OpenAI or Anthropic. It’ll come from a new feedback loop that learns from you. Introducing Beacon: open-source, self-improving memory for coding agents. Your sessions capture how you debug and solve problems. Today, that context gets lost and you have to re-explain things every time you switch tools. Beacon continuously distills your sessions into reusable skills across Claude Code, Cursor, Codex, and 20+ harnesses, so your next agent can learn from the last. Beacon is free and OSS 🌟 Why should the frontier labs be the only ones winning with your sessions? You already did the work. Now let your coding agents learn from you.

We’re betting our $5.5M seed round that the next leap in AI coding won’t come from OpenAI or Anthropic. It’ll come from a new feedback loop that learns from you. Introducing Beacon: open-source, self-improving memory for coding agents. Your sessions capture how you debug and solve problems. Today, that context gets lost and you have to re-explain things every time you switch tools. Beacon continuously distills your sessions into reusable skills across Claude Code, Cursor, Codex, and 20+ harnesses, so your next agent can learn from the last. Beacon is free and OSS 🌟 Why should the frontier labs be the only ones winning with your sessions? You already did the work. Now let your coding agents learn from you.

Justin D'Souza

631,633 görüntüleme • 17 gün önce

This is getting f*cking useful: Claude can build your app while JEV spots easy jobs that don’t need an expensive AI. Someone packed that setup into an open-source repo called jev-kit. The idea is simple: > Claude writes code and solves the hard problems. JEV checks whether the agent picked for a job is more powerful than it needs to be. > Sending an expensive worker to find a file? The kit can flag it and suggest a cheaper one. > In enforce mode, it can block dispatches that are 2 or more tiers above what JEV judges necessary. > It also checks tool calls and sends agents back when they claim they’re done without verifying their work. There’s an optional browser agent too: > JEV picks the clicks > Claude writes text into fields > Sonnet planner can help with tasks where the steps aren’t clear That’s the useful part: fewer small decisions left to the big model, with checks around the work it produces. Start in shadow mode. See what gets flagged before letting it block anything. JEV calls need a TypeSafe API key. paste this into Claude Code: “Inspect jonathanavis96/jev-kit. Read docs/install.md and run install/install.sh –check-only. Show how the tier guard and verification check fit my setup. Keep shadow mode on and show all proposed changes before installing.” Let Claude solve the hard part. Check who you’re paying to do the easy part.

This is getting f*cking useful: Claude can build your app while JEV spots easy jobs that don’t need an expensive AI. Someone packed that setup into an open-source repo called jev-kit. The idea is simple: > Claude writes code and solves the hard problems. JEV checks whether the agent picked for a job is more powerful than it needs to be. > Sending an expensive worker to find a file? The kit can flag it and suggest a cheaper one. > In enforce mode, it can block dispatches that are 2 or more tiers above what JEV judges necessary. > It also checks tool calls and sends agents back when they claim they’re done without verifying their work. There’s an optional browser agent too: > JEV picks the clicks > Claude writes text into fields > Sonnet planner can help with tasks where the steps aren’t clear That’s the useful part: fewer small decisions left to the big model, with checks around the work it produces. Start in shadow mode. See what gets flagged before letting it block anything. JEV calls need a TypeSafe API key. paste this into Claude Code: “Inspect jonathanavis96/jev-kit. Read docs/install.md and run install/install.sh –check-only. Show how the tier guard and verification check fit my setup. Keep shadow mode on and show all proposed changes before installing.” Let Claude solve the hard part. Check who you’re paying to do the easy part.

kiosa

14,772 görüntüleme • 23 gün önce

Three skills I use every day in Claude Code and Codex to solve my hardest problems: 1️⃣ /agent-watchdog When I have one agent like Codex working on a task and I don't fully trust it's going to do everything right, I'll open up another one like Claude Code and tell it to watchdog the Codex thread. You can copy the Codex deep link into Claude Code and it'll look at the prompt you sent, watch the Codex thread until it's done, then compare the Codex solution to how it was planning to solve it and automatically fix anything that Codex missed. It can also test the work of the other agent end-to-end. Similar to the idea of OpenRouter's new Fusion feature, I've definitely found that two models thinking through a problem and checking each other's work can be wildly more impactful than just one. 2️⃣ /plan-arbiter Similar ideas as /agent-watchdog - but with this one you have both make plans, compare plans, negotiate the differences, and make a final plan to execute. I find Claude Code is better at writing plans, but Codex is faster and cheaper to execute on them. Then I usually have Claude Code watchdog the Codex work and fix anything that was missed. 3️⃣ /read-the-damn-docs One thing that drives me crazy with coding agents is they're so reluctant to look up docs. They'll just guess and guess and guess at the right API surface for things, or the right solution to an integration of two things. Once I explicitly tell it to look up the docs, it says "Oh, I see the answer," and it fixes the problem. So I made the /read-the-damn-docs skill. Add it and your agents will know when and how to do efficient web searches to look up docs for the types of problems you really should look up docs for. All of these are totally open source over on my GitHub. If you try them, let me know your feedback. Will link to them below:

Three skills I use every day in Claude Code and Codex to solve my hardest problems: 1️⃣ /agent-watchdog When I have one agent like Codex working on a task and I don't fully trust it's going to do everything right, I'll open up another one like Claude Code and tell it to watchdog the Codex thread. You can copy the Codex deep link into Claude Code and it'll look at the prompt you sent, watch the Codex thread until it's done, then compare the Codex solution to how it was planning to solve it and automatically fix anything that Codex missed. It can also test the work of the other agent end-to-end. Similar to the idea of OpenRouter's new Fusion feature, I've definitely found that two models thinking through a problem and checking each other's work can be wildly more impactful than just one. 2️⃣ /plan-arbiter Similar ideas as /agent-watchdog - but with this one you have both make plans, compare plans, negotiate the differences, and make a final plan to execute. I find Claude Code is better at writing plans, but Codex is faster and cheaper to execute on them. Then I usually have Claude Code watchdog the Codex work and fix anything that was missed. 3️⃣ /read-the-damn-docs One thing that drives me crazy with coding agents is they're so reluctant to look up docs. They'll just guess and guess and guess at the right API surface for things, or the right solution to an integration of two things. Once I explicitly tell it to look up the docs, it says "Oh, I see the answer," and it fixes the problem. So I made the /read-the-damn-docs skill. Add it and your agents will know when and how to do efficient web searches to look up docs for the types of problems you really should look up docs for. All of these are totally open source over on my GitHub. If you try them, let me know your feedback. Will link to them below:

Steve (Builder.io)

43,089 görüntüleme • 4 ay önce

Boris Cherny gave Claude Code a memory that has no database, no indexing, no setup, and 80% of Anthropic runs on it a CLAUDE.md "gets automatically read into context at the start of every session" 12:48 - CLAUDE.md loads into memory every session 13:15 - Keep memory short or it burns your context 15:48 - Memory stacks from you to your whole company 17:30 - The memory command shows what Claude remembers 19:33 - Hit pound and Claude remembers it forever the whole memory layer is files → drop a CLAUDE.md in your repo and Claude reads it in on every session → nest more in subfolders and it pulls them only where it works → stack them personal to project to enterprise so one config serves the whole team → hit the pound key mid task and Claude writes the new fact into memory itself the best coding agent's memory was never a database, it was markdown you can open and edit

Boris Cherny gave Claude Code a memory that has no database, no indexing, no setup, and 80% of Anthropic runs on it a CLAUDE.md "gets automatically read into context at the start of every session" 12:48 - CLAUDE.md loads into memory every session 13:15 - Keep memory short or it burns your context 15:48 - Memory stacks from you to your whole company 17:30 - The memory command shows what Claude remembers 19:33 - Hit pound and Claude remembers it forever the whole memory layer is files → drop a CLAUDE.md in your repo and Claude reads it in on every session → nest more in subfolders and it pulls them only where it works → stack them personal to project to enterprise so one config serves the whole team → hit the pound key mid task and Claude writes the new fact into memory itself the best coding agent's memory was never a database, it was markdown you can open and edit

NO1ennn

13,015 görüntüleme • 3 ay önce