Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

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

70,794 görüntüleme • 16 gün önce •via X (Twitter)

16 Yorum

Leliu profil fotoğrafı
Leliu16 gün önce

This is a fascinating application of agent learning and memory.

鲅鱼二娃(互关) profil fotoğrafı
鲅鱼二娃(互关)15 gün önce

Passing along the lesson instead of the entire agent trace is the right abstraction. The tricky part, I imagine, is knowing when that lesson has gone stale as the codebase changes.

Nik profil fotoğrafı
Nik16 gün önce

Reusing trajectories across agents is the part I'd actually pay for. Which repo is it?

Avi Chawla profil fotoğrafı
Avi Chawla16 gün önce

Already in the post :)

BadGuyTy 🅁🅅🄽 (Tyler Hess) profil fotoğrafı
BadGuyTy 🅁🅅🄽 (Tyler Hess)16 gün önce

I was working on this with what I called origami. It would fold the context/memory for every post but since you are using the same model to build the context most of the process is in cache from the jev/sys1 context build. Keeps adding context chunks and grades which is best. The final answer is a context tailored to the exact situation. So it could like drop an explanation of an intermediary step that is not currently relevant to the problem at hand.

Trenita Fruge profil fotoğrafı
Trenita Fruge15 gün önce

memory layer that learns from corrections is basically meta-learning for inference

Rusty Shackleford profil fotoğrafı
Rusty Shackleford15 gün önce

damn boiiiiiiiiiiii

Harrison profil fotoğrafı
Harrison16 gün önce

can a later run retire a lesson? otherwise a bug gets patched but its workaround gets tenure.

Avi Chawla profil fotoğrafı
Avi Chawla16 gün önce

Yeah possible to do that if needed. You control the full setup.

Enrique Meza Costeno profil fotoğrafı
Enrique Meza Costeno15 gün önce

I did something similar with Memory As Service, but this is even better, thanks.

AtlasShoved profil fotoğrafı
AtlasShoved15 gün önce

@bot review this

安叫兽|Bird🕊️ 🔶 BNB profil fotoğrafı
安叫兽|Bird🕊️ 🔶 BNB16 gün önce

能少踩几次同一个坑就值了,别把坏习惯也同步过去

Y11 profil fotoğrafı
Y1115 gün önce

@grok 我需要买什么硬件设备,才能测验这篇文章讲到的内容? mac studio 32g m1 的可以吗?

Hailu 🍏 profil fotoğrafı
Hailu 🍏15 gün önce

Cách tiếp cận sáng tạo cho việc tái sử dụng kiến thức agent.

catman profil fotoğrafı
catman16 gün önce

The useful next step is to treat approved lessons like versioned code: test whether they actually prevent repeat errors, and give agents a way to retire stale guidance.

Emly profil fotoğrafı
Emly15 gün önce

Innovative approach to agent learning and knowledge sharing.

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.

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.

Akshay 🚀

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

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.

Akshay 🚀

30,088 görüntüleme • 15 gün ö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 ↓

rody

47,630 görüntüleme • 1 ay ö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.

Akshay 🚀

27,859 görüntüleme • 1 ay ö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!

Akshay 🚀

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