Pinned Tweet
My lecture at MIT!โจ
From Physics to Linear Algebra & Machine learning, I have learned a lot from MIT!
Yesterday, I had the honour of delivering a guest lecture on The state of AI Engineering, exploring:
- Prompt Engineering
- Retrieval Augmented Generation.
- Fine-Tuning Largd, how LLMs are bringing a paradigm shift
Thank you @RoyShilkrot for the invitation! ๐
Grateful for the opportunity to engage with such brilliant minds!
If you are interested AI Engineering, I write a free weekly newsletter โ @ML_Spring
From Physics to Linear Algebra & Machine learning, I have learned a lot from MIT!
Yesterday, I had the honour of delivering a guest lecture on The state of AI Engineering, exploring:
- Prompt Engineering
- Retrieval Augmented Generation.
- Fine-Tuning Largd, how LLMs are bringing a paradigm shift
Thank you @RoyShilkrot for the invitation! ๐
Grateful for the opportunity to engage with such brilliant minds!
If you are interested AI Engineering, I write a free weekly newsletter โ @ML_Spring
134
397
3,253
1,045,467
simply mind-blowing.
i've never heard an AI that sounded this human.
Dessa from Block can run fully locally on an M4 Max Mac, and it was trained only on human conversation audio with no text in the loop.
voice AI is solved!
i've never heard an AI that sounded this human.
Dessa from Block can run fully locally on an M4 Max Mac, and it was trained only on human conversation audio with no text in the loop.
voice AI is solved!
We believe voice is the most natural way to interact with intelligence, so we created Dessa, the most authentic full-duplex speech model ever built. Talking with it feels like talking with a personโฆfull of emotion, nuance, pauses, and a natural cadence.
block.xyz/dessa
22
5
120
14,722
PHP2Shell is a wake-up call for VPS security.
and if you're deploying personal agents, this one is for you:
PHP powers a huge part of the web, and this week two critical flaws in it leaked before they were meant to go public. they let anyone send a specially crafted request to own code on it, without ever logging in.
within days, bots were scanning the internet for servers to try it on. those bots aren't only looking for PHP, either. they scan every public server around the clock, hunting for anything left open.
a website can't hide from that, because it has to accept traffic from the public. its only real defense is patching fast.
this matters a lot right now, because so many people are running their own personal agents like OpenClaw and Hermes, often on a cheap VPS so they stay online 24/7.
the good news is that a personal agent is different from a website. it doesn't need to accept a single connection from the public internet, which means you can take its server off the internet entirely.
and you have good reason to, because that server holds a lot. your LLM API keys, your connected accounts, and an agent that can run shell commands all sit there, so one open port gives an attacker far more than a website ever would.
i walked through exactly how to do this in a video a few months back, and it's just as relevant today for any agent you self-host.
here are the three sections that matter most:
12:13 - Tailscale: making your server invisible to the internet
14:52 - locking down SSH + creating a non-root user
19:39 - firewall: blocking everything except Tailscale
before you lock it all down, turn off key expiry on the server's Tailscale node and keep your cloud provider's web console handy as a backup way in, so you never lock yourself out.
and if you're deploying personal agents, this one is for you:
PHP powers a huge part of the web, and this week two critical flaws in it leaked before they were meant to go public. they let anyone send a specially crafted request to own code on it, without ever logging in.
within days, bots were scanning the internet for servers to try it on. those bots aren't only looking for PHP, either. they scan every public server around the clock, hunting for anything left open.
a website can't hide from that, because it has to accept traffic from the public. its only real defense is patching fast.
this matters a lot right now, because so many people are running their own personal agents like OpenClaw and Hermes, often on a cheap VPS so they stay online 24/7.
the good news is that a personal agent is different from a website. it doesn't need to accept a single connection from the public internet, which means you can take its server off the internet entirely.
and you have good reason to, because that server holds a lot. your LLM API keys, your connected accounts, and an agent that can run shell commands all sit there, so one open port gives an attacker far more than a website ever would.
i walked through exactly how to do this in a video a few months back, and it's just as relevant today for any agent you self-host.
here are the three sections that matter most:
12:13 - Tailscale: making your server invisible to the internet
14:52 - locking down SSH + creating a non-root user
19:39 - firewall: blocking everything except Tailscale
before you lock it all down, turn off key expiry on the server's Tailscale node and keep your cloud provider's web console handy as a backup way in, so you never lock yourself out.
16
3
45
8,017
4 types of LLM caching, clearly explained.
(KV, prefix, prompt, and semantic caching)
An agent can send the same system instructions, tool definitions, and conversation history on every turn. Without reuse, the model processes that shared context again.
That initial prompt efill. It contributes to the wait before the first token appears.
The four caches in the graphic reduce repeated work at different points in this process.
๐ญ) ๐๐ฉ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐๐ฎ๐๐ฒ๐ ๐๐ผ๐ฟ๐ธ ๐ฏ๐ฒ๐๐๐ฒ๐ฒ๐ป ๐ด๐ฒ๐ป๐ฒ๐ฟ๐ฎ๐๐ฒ๐ฑ ๐๐ผ๐ธ๐ฒ๐ป๐.
During generation, the model stores keys and values, the vectors attention uses to retrieve information from earlier tokens. Each new token reuses those vectors and adds its own, avoiding repeated computation at the cost of memory.
๐ฎ) ๐ฃ๐ฟ๐ฒ๐ณ๐ถ๐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐๐ฎ๐๐ฒ๐ ๐๐ผ๐ฟ๐ธ ๐ฎ๐ฐ๐ฟ๐ผ๐๐ ๐ฟ๐ฒ๐พ๐๐ฒ๐๐๐.
When a request begins with an already processed sequence, the server can reuse its saved attention state and process the remaining suffix. This helps when requests share instructions, documents, or conversation history.
In vLLM, each cached blockโs identifier incorporates the preceding prefix, so identical text after a changed prefix is insufficient for reuse.
๐ฏ) ๐ฃ๐ฟ๐ผ๐บ๐ฝ๐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐ฝ๐๐๐ ๐๐ต๐ฒ ๐ฝ๐ฟ๐ผ๐๐ถ๐ฑ๐ฒ๐ฟ ๐ถ๐ป ๐ฐ๐ต๐ฎ๐ฟ๐ด๐ฒ.
A provider manages this prefix reuse through its API, including cache lifetimes and billing rules. Eligible repeated input receives discounted pricing, while the model still generates a fresh answer.
Put stable instructions and documents at the beginning, followed by the changing question, to preserve that reusable prefix.
๐ฐ) ๐ฆ๐ฒ๐บ๐ฎ๐ป๐๐ถ๐ฐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐ฟ๐ฒ๐๐๐ฒ๐ ๐๐ต๐ฒ ๐ฎ๐ป๐๐๐ฒ๐ฟ ๐ถ๐๐๐ฒ๐น๐ณ.
The system converts a prompt into an embedding, a numerical representation of its meaning, and searches for similar stored prompts. An accepted match returns the saved answer without calling the generation model, saving output tokens too.
This suits repeated questions with stable answers, but similarity alone cannot establish that an answer applies to the current user or situation.
These techniques can work together. A semantic cache miss can still benefit from a cached prompt prefix, then use KV caching during generation.
Prefix caching and provider prompt caching share the same underlying reuse. Semantic caching adds a different decision, whether a previous answer is still valid for this request.
That said, I also wrote a full breakdown of KV caching. The article is quoted below.
Hope you enjoyed reading.
Cheers! :)
(KV, prefix, prompt, and semantic caching)
An agent can send the same system instructions, tool definitions, and conversation history on every turn. Without reuse, the model processes that shared context again.
That initial prompt efill. It contributes to the wait before the first token appears.
The four caches in the graphic reduce repeated work at different points in this process.
๐ญ) ๐๐ฉ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐๐ฎ๐๐ฒ๐ ๐๐ผ๐ฟ๐ธ ๐ฏ๐ฒ๐๐๐ฒ๐ฒ๐ป ๐ด๐ฒ๐ป๐ฒ๐ฟ๐ฎ๐๐ฒ๐ฑ ๐๐ผ๐ธ๐ฒ๐ป๐.
During generation, the model stores keys and values, the vectors attention uses to retrieve information from earlier tokens. Each new token reuses those vectors and adds its own, avoiding repeated computation at the cost of memory.
๐ฎ) ๐ฃ๐ฟ๐ฒ๐ณ๐ถ๐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐๐ฎ๐๐ฒ๐ ๐๐ผ๐ฟ๐ธ ๐ฎ๐ฐ๐ฟ๐ผ๐๐ ๐ฟ๐ฒ๐พ๐๐ฒ๐๐๐.
When a request begins with an already processed sequence, the server can reuse its saved attention state and process the remaining suffix. This helps when requests share instructions, documents, or conversation history.
In vLLM, each cached blockโs identifier incorporates the preceding prefix, so identical text after a changed prefix is insufficient for reuse.
๐ฏ) ๐ฃ๐ฟ๐ผ๐บ๐ฝ๐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐ฝ๐๐๐ ๐๐ต๐ฒ ๐ฝ๐ฟ๐ผ๐๐ถ๐ฑ๐ฒ๐ฟ ๐ถ๐ป ๐ฐ๐ต๐ฎ๐ฟ๐ด๐ฒ.
A provider manages this prefix reuse through its API, including cache lifetimes and billing rules. Eligible repeated input receives discounted pricing, while the model still generates a fresh answer.
Put stable instructions and documents at the beginning, followed by the changing question, to preserve that reusable prefix.
๐ฐ) ๐ฆ๐ฒ๐บ๐ฎ๐ป๐๐ถ๐ฐ ๐ฐ๐ฎ๐ฐ๐ต๐ถ๐ป๐ด ๐ฟ๐ฒ๐๐๐ฒ๐ ๐๐ต๐ฒ ๐ฎ๐ป๐๐๐ฒ๐ฟ ๐ถ๐๐๐ฒ๐น๐ณ.
The system converts a prompt into an embedding, a numerical representation of its meaning, and searches for similar stored prompts. An accepted match returns the saved answer without calling the generation model, saving output tokens too.
This suits repeated questions with stable answers, but similarity alone cannot establish that an answer applies to the current user or situation.
These techniques can work together. A semantic cache miss can still benefit from a cached prompt prefix, then use KV caching during generation.
Prefix caching and provider prompt caching share the same underlying reuse. Semantic caching adds a different decision, whether a previous answer is still valid for this request.
That said, I also wrote a full breakdown of KV caching. The article is quoted below.
Hope you enjoyed reading.
Cheers! :)
41
52
299
15,289
Akshay ๐ retweeted
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 de
- Codex
- Cursor
- OpenCode
- and more.
The project is Beacon, from @asymptotelabs.
GitHub: github.com/Asymptote-Labsโฆ
(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.
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 de
- Codex
- Cursor
- OpenCode
- and more.
The project is Beacon, from @asymptotelabs.
GitHub: github.com/Asymptote-Labsโฆ
(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.
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
47
43
366
28,188
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 de
- Codex
- Cursor
- OpenCode
- and more.
The project is Beacon, from @asymptotelabs.
GitHub: github.com/Asymptote-Labsโฆ
(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.
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 de
- Codex
- Cursor
- OpenCode
- and more.
The project is Beacon, from @asymptotelabs.
GitHub: github.com/Asymptote-Labsโฆ
(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.
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
47
43
366
28,188
Should have named this Clawdbot.
Weโre opening a research preview of Claude Duet, a new app where Claude works as a proactive agent.
It comes to you with what needs your attention, completes tasks you ask of it, keeps working when you step away, and checks with you before it acts on your behalf.
0
1
72
13,031
Akshay ๐ retweeted
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
113
30
308
49,308
Another blow to Anthropic!
Devs built a free and better Claude desktop alternative that:
- runs locally
- works with any LLM
- SOTA deep research
- has Cowork-like capabilities
- connects to 40+ data sources
- self-hosts via Docker, and more.
100% open-source.
Devs built a free and better Claude desktop alternative that:
- runs locally
- works with any LLM
- SOTA deep research
- has Cowork-like capabilities
- connects to 40+ data sources
- self-hosts via Docker, and more.
100% open-source.
55
139
1,042
62,454
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
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 nsfer 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 @jqdsouza, 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: github.com/Asymptote-Labsโฆ
(don't forget to star ๐)
Enjoy the episode.
Cheers!
113
30
308
49,308
Anatomy of a Jev request!
Wiring an LLM into code usually means asking for JSON, then handling every case where the output drifts from the schema.
Jev, TypeSafe's decision model, doesn't write text at all. Every answer is one of the options you defined, with a probability goes straight into an if statement.
A Jev request has two parts.
The state is the thing being judged. It can be a customer message, a database record, or now a photo.
The questions are the judgments you want back. You can send several in one request, and they all look at the same state and run in parallel.
Each question has an instruction, which is the question written in plain words. Some questions also carry criteria, the set of answers Jev is allowed to return.
There are four question types.
1) Choice picks one option from a list you define, like routing a ticket to billing, technical or sales. You get the option name plus a probability for every option.
2) Noul is a yes-or-no question. Instead of a hard yes or no, it returns the probability that the answer is yes, and your code decides the threshold.
3) Score places the state on an ordered scale you define, like how frustrated a customer sounds, from calm to very angry. The answer can land between two levels.
4) Box is new in the latest release. You ask where something is in an image, and it returns the four edges of a rectangle around it, as fractions of the image's width and height.
Box always returns a rectangle, even when the thing isn't in the image. That's why it's usually paired with a Noul asking whether the object is there at all.
Images come in through a new assets field. Each image gets a reference string, and wherever that string appears in the state, an instruction or the criteria, Jev sees the image instead.
The full walkthrough, with the live demo and the code, is in my video quoted below on multimodal Jev.
You can also watch it on YouTube: youtube.com/watch?v=ciQghnโฆ
Wiring an LLM into code usually means asking for JSON, then handling every case where the output drifts from the schema.
Jev, TypeSafe's decision model, doesn't write text at all. Every answer is one of the options you defined, with a probability goes straight into an if statement.
A Jev request has two parts.
The state is the thing being judged. It can be a customer message, a database record, or now a photo.
The questions are the judgments you want back. You can send several in one request, and they all look at the same state and run in parallel.
Each question has an instruction, which is the question written in plain words. Some questions also carry criteria, the set of answers Jev is allowed to return.
There are four question types.
1) Choice picks one option from a list you define, like routing a ticket to billing, technical or sales. You get the option name plus a probability for every option.
2) Noul is a yes-or-no question. Instead of a hard yes or no, it returns the probability that the answer is yes, and your code decides the threshold.
3) Score places the state on an ordered scale you define, like how frustrated a customer sounds, from calm to very angry. The answer can land between two levels.
4) Box is new in the latest release. You ask where something is in an image, and it returns the four edges of a rectangle around it, as fractions of the image's width and height.
Box always returns a rectangle, even when the thing isn't in the image. That's why it's usually paired with a Noul asking whether the object is there at all.
Images come in through a new assets field. Each image gets a reference string, and wherever that string appears in the state, an instruction or the criteria, Jev sees the image instead.
The full walkthrough, with the live demo and the code, is in my video quoted below on multimodal Jev.
You can also watch it on YouTube: youtube.com/watch?v=ciQghnโฆ
Jev is now multimodal. It can see.
Hereโs how it works and what you can build with it:
Jev is a decision model. You give it information, ask questions, and get answers your code can use directly.
Previously, that information was text or JSON. Now it can include images.
Start works.
You send a โstate,โ which is simply the information you want Jev to examine. Then you ask questions about it.
Each question specifies the kind of answer you need.
โ Choice picks from options you define, such as โthumbs upโ or โfist.โ
โ Noul returns the probability that something is true, such as whether a hand is visible.
โ Score rates something on a scale you define, such as how open the hand is.
With multimodal Jev, images can be part of both the state and the questions.
Put a camera frame in the state, and your questions can ask about whatโs visible in it.
Put a reference photo in a questionโs instructions, and you can ask whether an object in the camera frame matches the one in that photo.
Jev can now also identify an object and locate it for you.
The new Box type brings a YOLO-like capability to Jev. Describe what you want to find, such as โthe hand in this image,โ and it returns a bounding box around it.
Your app can use those coordinates to highlight the object or crop it.
One detail matters here. Box returns coordinates even when the target is absent, so pair it with a Noul presence check before using the result.
My demo asks about presence, gesture, and location together. Jev answers these independent questions in parallel, and the app combines the results.
These capabilities open up prototypes for gesture controls, locating buttons in screenshots, and checking product photos against visual references.
Jevโs focus on fast decisions also makes it promising for interactive applications where response time matters, with image latency worth testing in your own workflow.
Images and Box are still experimental and require the images โdanger zoneโ header.
I cover how it works, the API, and the demo app in the detailed video below.
Chapters
0:00 Intro
0:36 Live demo
1:41 What's covered
2:22 How Jev works
3:06 Question types
3:57 Playground demo
6:59 Demo app walkthrough
10:30 Using Multiple images
11:25 Parallel questions
12:40 Danger zone headers
13:07 Outro
If youโre new to Jev and want to understand how decision models work, Iโve written a detailed article about it. Itโs quoted below.
22
12
98
10,398
Google just open-sourced Harnessยฒ.
(turn any harness into a self-improving system)
a harness is everything wrapped around the model, like the system prompt, tools, memory, skills, and subagents. today a person designs it once, and the agent runs every new task with that same lets the agent refine that setup for each new task on its own, with the model weights left untouched.
on every task, the agent proposes edits to its harness, runs a few candidate versions, and composes a better harness by comparing how those runs behaved.
because it learns from the differences between runs, it needs no correct answer or grader for the task.
that covers a single task. Harnessยฒ also carries what it learns from one task into the next.
after each task, it saves the harness it settled on along with the lessons that held up across the runs. the next time it refines a harness, it starts from those notes instead of from scratch.
this means every finished task makes the next round of edits more informed.
Google tested this with Gemini 3.5 Flash and GLM-5 on legal, office, and professional work benchmarks. one round of edits was enough to beat their original harnesses, and giving the agent more rounds pushed scores higher.
those extra rounds can go wide or deep. the agent either tries several candidate harnesses at once or keeps refining a single one step by step, using OpenCode or Codex to carry out the work.
you can find the Harnessยฒ repo here: github.com/google-researcโฆ
I wrote about a similar idea for agents already running in production, where the harness should repair itself after a failure instead of waiting for someone to debug the trace by hand.
that piece walks through how @Cometml's Opik (open-source) closes this loop, going from a failing trace to a proposed fix to a regression test that stops the same failure from coming back. it's quoted below.
(turn any harness into a self-improving system)
a harness is everything wrapped around the model, like the system prompt, tools, memory, skills, and subagents. today a person designs it once, and the agent runs every new task with that same lets the agent refine that setup for each new task on its own, with the model weights left untouched.
on every task, the agent proposes edits to its harness, runs a few candidate versions, and composes a better harness by comparing how those runs behaved.
because it learns from the differences between runs, it needs no correct answer or grader for the task.
that covers a single task. Harnessยฒ also carries what it learns from one task into the next.
after each task, it saves the harness it settled on along with the lessons that held up across the runs. the next time it refines a harness, it starts from those notes instead of from scratch.
this means every finished task makes the next round of edits more informed.
Google tested this with Gemini 3.5 Flash and GLM-5 on legal, office, and professional work benchmarks. one round of edits was enough to beat their original harnesses, and giving the agent more rounds pushed scores higher.
those extra rounds can go wide or deep. the agent either tries several candidate harnesses at once or keeps refining a single one step by step, using OpenCode or Codex to carry out the work.
you can find the Harnessยฒ repo here: github.com/google-researcโฆ
I wrote about a similar idea for agents already running in production, where the harness should repair itself after a failure instead of waiting for someone to debug the trace by hand.
that piece walks through how @Cometml's Opik (open-source) closes this loop, going from a failing trace to a proposed fix to a regression test that stops the same failure from coming back. it's quoted below.
344
991
7,485
744,168
Agents 2.0 is here.
Anthropic.
OpenAI.
xAI.
Are all racing to build your next AI coworker.
Agents that can work alongside humans, talk to other agents, and coordinate tasks in a shared workspace.
But thereโs a catch.
Each product ties the model, runtime, memory, and mpanyโs stack.
Most teams wonโt use one provider for every job. They may use Claude Code, Codex, OpenCode running locally, and custom agents for internal systems. Making them collaborate with each other and your team usually means building the glue yourself.
That is vendor lock-in.
Today, weโll see how to bring humans and agents from different providers into one shared workspace using an open-source coordination layer you can host yourself.
Humans can talk directly to agents. Agents can talk to each other. And people can join the conversation, add context, or give further instructions as the work unfolds.
The project is called Switch, and it brings this collaboration into Slack, Teams, Discord, Telegram, or Mattermost.
You give each agent a role and can work through a Manager. The Manager creates rooms, brings in the relevant agents, carries context between them, and returns the result.
In this video, I gave the Manager two incidents.
โ The inference API started returning 500s after a morning deploy
โ A recommendation-model training job had been frozen for six hours
From one message, it created two linked rooms, brought in a Software Engineer, Architect, and QA Lead, and ran both investigations in parallel.
Then the engineer investigating the training failure checked the linked inference room and spotted the same config push behind both failures.
The Manager returned one consolidated RCA to the original channel.
Throughout the run, I could follow the conversations, give additional instructions, and inspect the underlying agent sessions in Switch Console.
That is what I mean by Agents 2.0. Humans and agents working together, sharing context, and contributing as the work unfolds.
I build everything locally with Docker and Mattermost and follow the run through to the final handoff.
Models will keep changing, so the coordination layer should be able to run separately from any one provider.
GitHub: github.com/sandbox-quantuโฆ
(don't forgot to star ๐)
Chapters:
0:00 Intro
1:12 Installing Switch Console
2:59 Setting up the server & agent providers
4:29 Creating your agents
7:57 Creating a room & adding the manager
9:04 Handing the manager two P0 incidents
9:56 The team spins up incident rooms
11:07 Watching agent sessions in Switch Console
13:48 Investigation results
14:29 Outro
Enjoy!
Anthropic.
OpenAI.
xAI.
Are all racing to build your next AI coworker.
Agents that can work alongside humans, talk to other agents, and coordinate tasks in a shared workspace.
But thereโs a catch.
Each product ties the model, runtime, memory, and mpanyโs stack.
Most teams wonโt use one provider for every job. They may use Claude Code, Codex, OpenCode running locally, and custom agents for internal systems. Making them collaborate with each other and your team usually means building the glue yourself.
That is vendor lock-in.
Today, weโll see how to bring humans and agents from different providers into one shared workspace using an open-source coordination layer you can host yourself.
Humans can talk directly to agents. Agents can talk to each other. And people can join the conversation, add context, or give further instructions as the work unfolds.
The project is called Switch, and it brings this collaboration into Slack, Teams, Discord, Telegram, or Mattermost.
You give each agent a role and can work through a Manager. The Manager creates rooms, brings in the relevant agents, carries context between them, and returns the result.
In this video, I gave the Manager two incidents.
โ The inference API started returning 500s after a morning deploy
โ A recommendation-model training job had been frozen for six hours
From one message, it created two linked rooms, brought in a Software Engineer, Architect, and QA Lead, and ran both investigations in parallel.
Then the engineer investigating the training failure checked the linked inference room and spotted the same config push behind both failures.
The Manager returned one consolidated RCA to the original channel.
Throughout the run, I could follow the conversations, give additional instructions, and inspect the underlying agent sessions in Switch Console.
That is what I mean by Agents 2.0. Humans and agents working together, sharing context, and contributing as the work unfolds.
I build everything locally with Docker and Mattermost and follow the run through to the final handoff.
Models will keep changing, so the coordination layer should be able to run separately from any one provider.
GitHub: github.com/sandbox-quantuโฆ
(don't forgot to star ๐)
Chapters:
0:00 Intro
1:12 Installing Switch Console
2:59 Setting up the server & agent providers
4:29 Creating your agents
7:57 Creating a room & adding the manager
9:04 Handing the manager two P0 incidents
9:56 The team spins up incident rooms
11:07 Watching agent sessions in Switch Console
13:48 Investigation results
14:29 Outro
Enjoy!
45
15
165
17,934
Akshay ๐ retweeted
Jev is now multimodal. It can see.
Hereโs how it works and what you can build with it:
Jev is a decision model. You give it information, ask questions, and get answers your code can use directly.
Previously, that information was text or JSON. Now it can include images.
Start works.
You send a โstate,โ which is simply the information you want Jev to examine. Then you ask questions about it.
Each question specifies the kind of answer you need.
โ Choice picks from options you define, such as โthumbs upโ or โfist.โ
โ Noul returns the probability that something is true, such as whether a hand is visible.
โ Score rates something on a scale you define, such as how open the hand is.
With multimodal Jev, images can be part of both the state and the questions.
Put a camera frame in the state, and your questions can ask about whatโs visible in it.
Put a reference photo in a questionโs instructions, and you can ask whether an object in the camera frame matches the one in that photo.
Jev can now also identify an object and locate it for you.
The new Box type brings a YOLO-like capability to Jev. Describe what you want to find, such as โthe hand in this image,โ and it returns a bounding box around it.
Your app can use those coordinates to highlight the object or crop it.
One detail matters here. Box returns coordinates even when the target is absent, so pair it with a Noul presence check before using the result.
My demo asks about presence, gesture, and location together. Jev answers these independent questions in parallel, and the app combines the results.
These capabilities open up prototypes for gesture controls, locating buttons in screenshots, and checking product photos against visual references.
Jevโs focus on fast decisions also makes it promising for interactive applications where response time matters, with image latency worth testing in your own workflow.
Images and Box are still experimental and require the images โdanger zoneโ header.
I cover how it works, the API, and the demo app in the detailed video below.
Chapters
0:00 Intro
0:36 Live demo
1:41 What's covered
2:22 How Jev works
3:06 Question types
3:57 Playground demo
6:59 Demo app walkthrough
10:30 Using Multiple images
11:25 Parallel questions
12:40 Danger zone headers
13:07 Outro
If youโre new to Jev and want to understand how decision models work, Iโve written a detailed article about it. Itโs quoted below.
Hereโs how it works and what you can build with it:
Jev is a decision model. You give it information, ask questions, and get answers your code can use directly.
Previously, that information was text or JSON. Now it can include images.
Start works.
You send a โstate,โ which is simply the information you want Jev to examine. Then you ask questions about it.
Each question specifies the kind of answer you need.
โ Choice picks from options you define, such as โthumbs upโ or โfist.โ
โ Noul returns the probability that something is true, such as whether a hand is visible.
โ Score rates something on a scale you define, such as how open the hand is.
With multimodal Jev, images can be part of both the state and the questions.
Put a camera frame in the state, and your questions can ask about whatโs visible in it.
Put a reference photo in a questionโs instructions, and you can ask whether an object in the camera frame matches the one in that photo.
Jev can now also identify an object and locate it for you.
The new Box type brings a YOLO-like capability to Jev. Describe what you want to find, such as โthe hand in this image,โ and it returns a bounding box around it.
Your app can use those coordinates to highlight the object or crop it.
One detail matters here. Box returns coordinates even when the target is absent, so pair it with a Noul presence check before using the result.
My demo asks about presence, gesture, and location together. Jev answers these independent questions in parallel, and the app combines the results.
These capabilities open up prototypes for gesture controls, locating buttons in screenshots, and checking product photos against visual references.
Jevโs focus on fast decisions also makes it promising for interactive applications where response time matters, with image latency worth testing in your own workflow.
Images and Box are still experimental and require the images โdanger zoneโ header.
I cover how it works, the API, and the demo app in the detailed video below.
Chapters
0:00 Intro
0:36 Live demo
1:41 What's covered
2:22 How Jev works
3:06 Question types
3:57 Playground demo
6:59 Demo app walkthrough
10:30 Using Multiple images
11:25 Parallel questions
12:40 Danger zone headers
13:07 Outro
If youโre new to Jev and want to understand how decision models work, Iโve written a detailed article about it. Itโs quoted below.
23
29
212
25,912
Stanford just reinvented text generation.
(itโs neither autoregressive nor diffusion)
Autoregressive LLMs generate one token at a time. Longer answers require longer chains of sequential predictions.
Diffusion LLMs generate many tokens in parallel, but still need repeated pass processes the full sequence, and quality drops quickly when you cut the passes.
Stanford researchers proposed another approach, Next-Concept Modeling (NCM). It generates text from coarse structure to fine detail in roughly a dozen passes.
First, a tokenizer learns to represent text as layers of compressed information. Early layers capture broad structure, while later layers add details the earlier ones missed.
A transformer then learns to generate these layers in order, predicting everything within each layer simultaneously. A decoder converts the completed representation into text.
The advantage is that early layers are tiny. Generation needs fewer passes, and those early passes process much less information.
You can see this in the teamโs translation example. Early layers produce rough, repetitive text, which later layers refine into a clean translation.
In the researchersโ tests, NCM generated text 10โ31ร faster than strong diffusion baselines, with comparable or better benchmark scores. On LM1B and OpenWebText, it also used roughly 4โ5ร fewer training tokens, including tokenizer training.
That speed can also improve quality. Generating several candidates and selecting one based on agreement outperformed diffusion baselines at the same sampling time budget.
The limits matter. Scaling experiments reach 725M parameters, tasks use separate tokenizers, and the release includes evaluation code and checkpoints without a training pipeline.
Some evaluations also use repetition penalties during final decoding, without additional model calls.
NCM shows that parallel generation can work by building increasingly detailed representations. Whether those gains hold at general-purpose LLM scale remains open.
- GitHub repo: github.com/HazyResearch/nโฆ
- Paper: arxiv.org/abs/2610.14162
(itโs neither autoregressive nor diffusion)
Autoregressive LLMs generate one token at a time. Longer answers require longer chains of sequential predictions.
Diffusion LLMs generate many tokens in parallel, but still need repeated pass processes the full sequence, and quality drops quickly when you cut the passes.
Stanford researchers proposed another approach, Next-Concept Modeling (NCM). It generates text from coarse structure to fine detail in roughly a dozen passes.
First, a tokenizer learns to represent text as layers of compressed information. Early layers capture broad structure, while later layers add details the earlier ones missed.
A transformer then learns to generate these layers in order, predicting everything within each layer simultaneously. A decoder converts the completed representation into text.
The advantage is that early layers are tiny. Generation needs fewer passes, and those early passes process much less information.
You can see this in the teamโs translation example. Early layers produce rough, repetitive text, which later layers refine into a clean translation.
In the researchersโ tests, NCM generated text 10โ31ร faster than strong diffusion baselines, with comparable or better benchmark scores. On LM1B and OpenWebText, it also used roughly 4โ5ร fewer training tokens, including tokenizer training.
That speed can also improve quality. Generating several candidates and selecting one based on agreement outperformed diffusion baselines at the same sampling time budget.
The limits matter. Scaling experiments reach 725M parameters, tasks use separate tokenizers, and the release includes evaluation code and checkpoints without a training pipeline.
Some evaluations also use repetition penalties during final decoding, without additional model calls.
NCM shows that parallel generation can work by building increasingly detailed representations. Whether those gains hold at general-purpose LLM scale remains open.
- GitHub repo: github.com/HazyResearch/nโฆ
- Paper: arxiv.org/abs/2610.14162
39
81
555
25,442
Jev is now multimodal. It can see.
Hereโs how it works and what you can build with it:
Jev is a decision model. You give it information, ask questions, and get answers your code can use directly.
Previously, that information was text or JSON. Now it can include images.
Start works.
You send a โstate,โ which is simply the information you want Jev to examine. Then you ask questions about it.
Each question specifies the kind of answer you need.
โ Choice picks from options you define, such as โthumbs upโ or โfist.โ
โ Noul returns the probability that something is true, such as whether a hand is visible.
โ Score rates something on a scale you define, such as how open the hand is.
With multimodal Jev, images can be part of both the state and the questions.
Put a camera frame in the state, and your questions can ask about whatโs visible in it.
Put a reference photo in a questionโs instructions, and you can ask whether an object in the camera frame matches the one in that photo.
Jev can now also identify an object and locate it for you.
The new Box type brings a YOLO-like capability to Jev. Describe what you want to find, such as โthe hand in this image,โ and it returns a bounding box around it.
Your app can use those coordinates to highlight the object or crop it.
One detail matters here. Box returns coordinates even when the target is absent, so pair it with a Noul presence check before using the result.
My demo asks about presence, gesture, and location together. Jev answers these independent questions in parallel, and the app combines the results.
These capabilities open up prototypes for gesture controls, locating buttons in screenshots, and checking product photos against visual references.
Jevโs focus on fast decisions also makes it promising for interactive applications where response time matters, with image latency worth testing in your own workflow.
Images and Box are still experimental and require the images โdanger zoneโ header.
I cover how it works, the API, and the demo app in the detailed video below.
Chapters
0:00 Intro
0:36 Live demo
1:41 What's covered
2:22 How Jev works
3:06 Question types
3:57 Playground demo
6:59 Demo app walkthrough
10:30 Using Multiple images
11:25 Parallel questions
12:40 Danger zone headers
13:07 Outro
If youโre new to Jev and want to understand how decision models work, Iโve written a detailed article about it. Itโs quoted below.
Hereโs how it works and what you can build with it:
Jev is a decision model. You give it information, ask questions, and get answers your code can use directly.
Previously, that information was text or JSON. Now it can include images.
Start works.
You send a โstate,โ which is simply the information you want Jev to examine. Then you ask questions about it.
Each question specifies the kind of answer you need.
โ Choice picks from options you define, such as โthumbs upโ or โfist.โ
โ Noul returns the probability that something is true, such as whether a hand is visible.
โ Score rates something on a scale you define, such as how open the hand is.
With multimodal Jev, images can be part of both the state and the questions.
Put a camera frame in the state, and your questions can ask about whatโs visible in it.
Put a reference photo in a questionโs instructions, and you can ask whether an object in the camera frame matches the one in that photo.
Jev can now also identify an object and locate it for you.
The new Box type brings a YOLO-like capability to Jev. Describe what you want to find, such as โthe hand in this image,โ and it returns a bounding box around it.
Your app can use those coordinates to highlight the object or crop it.
One detail matters here. Box returns coordinates even when the target is absent, so pair it with a Noul presence check before using the result.
My demo asks about presence, gesture, and location together. Jev answers these independent questions in parallel, and the app combines the results.
These capabilities open up prototypes for gesture controls, locating buttons in screenshots, and checking product photos against visual references.
Jevโs focus on fast decisions also makes it promising for interactive applications where response time matters, with image latency worth testing in your own workflow.
Images and Box are still experimental and require the images โdanger zoneโ header.
I cover how it works, the API, and the demo app in the detailed video below.
Chapters
0:00 Intro
0:36 Live demo
1:41 What's covered
2:22 How Jev works
3:06 Question types
3:57 Playground demo
6:59 Demo app walkthrough
10:30 Using Multiple images
11:25 Parallel questions
12:40 Danger zone headers
13:07 Outro
If youโre new to Jev and want to understand how decision models work, Iโve written a detailed article about it. Itโs quoted below.
23
29
212
25,912
reverse engineer anything.
(100% open-source, 200k+ stars)
when you like a feature in someone else's app, you usually can't see how it was built because the source code isn't available. figuring it out used to mean hours jumping between 10+ specialized tools and reading machine n open-source MCP server that hands this work to your agent. you give it an app and a question, and the agent traces the feature down to the compiled code, explains how it works, and can build a version for your own project.
how it works:
REA brings the tools reverse engineers rely on, like Ghidra, IDA and JADX, under one interface that Claude Code, Codex, Cursor and other agents can call.
your agent asks REA to inspect the app, and REA picks the right tool, runs it locally, and returns what it found along with the evidence behind each finding.
the agent then uses those findings to dig further, explain the behavior, or write and test its own version. since every claim points back to real code, the agent works from evidence instead of guessing.
what you can do with it
โณ see how a desktop app like Notion handles copy and paste, from the button you click to the code that runs behind it.
โณ look inside compiled programs and games to understand the logic they were built on.
โณ break down Android apps into readable code to see how a feature is put together.
โณ inspect how a website is structured and what it sends over the network.
โณ examine device firmware, network recordings and other files that were never meant to be read by people.
in one of their showcases, it rebuilt a sound function from the old DX-Ball game that compiles back to the exact same code as the original.
everything runs on your machine, and setup adds it to your agent with a single command: ๐ป๐ฝ๐ ๐ฟ๐ฒ๐ฎ-๐ฎ๐ด๐ฒ๐ป๐๐ ๐๐ฒ๐๐๐ฝ
it's meant for software you own or are authorized to analyze.
repo: github.com/morluto/rea
a while back, i wrote about two gaps in Claude Code. it only gets a summary when it reads a web page instead of the full content, and it can't see the full state of your backend. adding the right skills fixes both.
REA builds on that same setup and covers one more gap, since your agent can now understand apps it never had the source code for.
the full article is in the quoted post below.
(100% open-source, 200k+ stars)
when you like a feature in someone else's app, you usually can't see how it was built because the source code isn't available. figuring it out used to mean hours jumping between 10+ specialized tools and reading machine n open-source MCP server that hands this work to your agent. you give it an app and a question, and the agent traces the feature down to the compiled code, explains how it works, and can build a version for your own project.
how it works:
REA brings the tools reverse engineers rely on, like Ghidra, IDA and JADX, under one interface that Claude Code, Codex, Cursor and other agents can call.
your agent asks REA to inspect the app, and REA picks the right tool, runs it locally, and returns what it found along with the evidence behind each finding.
the agent then uses those findings to dig further, explain the behavior, or write and test its own version. since every claim points back to real code, the agent works from evidence instead of guessing.
what you can do with it
โณ see how a desktop app like Notion handles copy and paste, from the button you click to the code that runs behind it.
โณ look inside compiled programs and games to understand the logic they were built on.
โณ break down Android apps into readable code to see how a feature is put together.
โณ inspect how a website is structured and what it sends over the network.
โณ examine device firmware, network recordings and other files that were never meant to be read by people.
in one of their showcases, it rebuilt a sound function from the old DX-Ball game that compiles back to the exact same code as the original.
everything runs on your machine, and setup adds it to your agent with a single command: ๐ป๐ฝ๐ ๐ฟ๐ฒ๐ฎ-๐ฎ๐ด๐ฒ๐ป๐๐ ๐๐ฒ๐๐๐ฝ
it's meant for software you own or are authorized to analyze.
repo: github.com/morluto/rea
a while back, i wrote about two gaps in Claude Code. it only gets a summary when it reads a web page instead of the full content, and it can't see the full state of your backend. adding the right skills fixes both.
REA builds on that same setup and covers one more gap, since your agent can now understand apps it never had the source code for.
the full article is in the quoted post below.
52
99
575
33,822