Loading video...

Video Failed to Load

Go Home

Top 12 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 12 practical use cases for Jev: 1. Browser next action > Convert the current DOM...

_avichawla's profile picture

Avi Chawla

78,303 subscribers

97,392 views • 1 day ago •via X (Twitter)

Science & Technology
LIVE

Anya Rossi• Live Now

Private livecam show

0 Comments

No comments available

Comments from the original post will appear here

Related Videos

You can now use Jev right inside Claude Code 🤯 It's called jev-model-router, an early access mod built on Claude Code's new function hooks. Before every turn, it checks in with Jev and asks: > how mechanical the task is > how much reasoning it needs > whether it's risky Then it routes: → it'll move up to a stronger model on weak evidence, and only drops to a cheaper one when it's confident the task is simple → every decision gets logged in your transcript → if the call fails, your request runs untouched Setup: 1. copy the install command: npx claude-code-templates@latest --mod productivity/jev-model-router 2. paste it inside Claude Code 3. run claude with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 set 4. accept the trust prompt on first launch Link: Also works with no api key, it just falls back to a built-in classifier with no confidence score. For real jev routing, add your typesafeApiKey or gatewayApiKey to ~/.claude/settings.json. Follow me for more AI workflows and tutorials.
0:15

You can now use Jev right inside Claude Code 🤯 It's called jev-model-router, an early access mod built on Claude Code's new function hooks. Before every turn, it checks in with Jev and asks: > how mechanical the task is > how much reasoning it needs > whether it's risky Then it routes: → it'll move up to a stronger model on weak evidence, and only drops to a cheaper one when it's confident the task is simple → every decision gets logged in your transcript → if the call fails, your request runs untouched Setup: 1. copy the install command: npx claude-code-templates@latest --mod productivity/jev-model-router 2. paste it inside Claude Code 3. run claude with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 set 4. accept the trust prompt on first launch Link: Also works with no api key, it just falls back to a built-in classifier with no confidence score. For real jev routing, add your typesafeApiKey or gatewayApiKey to ~/.claude/settings.json. Follow me for more AI workflows and tutorials.

Alvaro Cintas

41,891 views • 7 days ago

Jev + SERV is actually insane. We already showed you can increase Jev's performance with SERV Reasoning. Now we're taking it further, bringing Jev-powered Decision nodes into Graph Sharding with the upcoming SERV v3. Here's a breakdown of how it works: Jev is a decision-making model. Given a task and a set of options, it predicts which path is more likely. Think of the octopus that predicted World Cup results. Jev does that for your business, except it's not luck. It weighs every option and tells you how sure it is. It does this by assigning probabilities to outcomes. It doesn't generate text on its own, so you can't expect it to create a new outcome for you. But that's also what enables it to be lightning fast and dirt cheap. For example, in customer service you can ask Jev how to triage an incoming query and route it to the correct department. It can only select from the list of departments you provide it. This also means it can't hallucinate a new outcome outside the options it's given, which makes it incredibly interesting for OpenServ. In Graph Sharding, we take a single system prompt and break it down into multiple LLM steps with deterministic input and output shapes. Some of these steps require an LLM to produce new output, while others are simply decision routers that determine the next possible path. Traditionally, LLMs are slow and expensive. Breaking a single prompt into multiple steps increases accuracy and reliability by a ton, but it also introduces latency. Jev takes on those decision nodes, which are the backbone of a business process and therefore SERV graphs, and makes them super consistent and lightning fast, lowering the overall cost and latency of graph execution. SERV Reasoning on its own is a great force multiplier for Jev because, like all other models, it works by interpreting input instructions. The clearer those instructions are, the better the model performs. That's where SERV Reasoning comes into play. Just like amplifying any other model, we also amplify the accuracy and consistency of Jev's responses. And now we're bringing Jev-powered Decision nodes into Graph Sharding with SERV v3.
0:13

Jev + SERV is actually insane. We already showed you can increase Jev's performance with SERV Reasoning. Now we're taking it further, bringing Jev-powered Decision nodes into Graph Sharding with the upcoming SERV v3. Here's a breakdown of how it works: Jev is a decision-making model. Given a task and a set of options, it predicts which path is more likely. Think of the octopus that predicted World Cup results. Jev does that for your business, except it's not luck. It weighs every option and tells you how sure it is. It does this by assigning probabilities to outcomes. It doesn't generate text on its own, so you can't expect it to create a new outcome for you. But that's also what enables it to be lightning fast and dirt cheap. For example, in customer service you can ask Jev how to triage an incoming query and route it to the correct department. It can only select from the list of departments you provide it. This also means it can't hallucinate a new outcome outside the options it's given, which makes it incredibly interesting for OpenServ. In Graph Sharding, we take a single system prompt and break it down into multiple LLM steps with deterministic input and output shapes. Some of these steps require an LLM to produce new output, while others are simply decision routers that determine the next possible path. Traditionally, LLMs are slow and expensive. Breaking a single prompt into multiple steps increases accuracy and reliability by a ton, but it also introduces latency. Jev takes on those decision nodes, which are the backbone of a business process and therefore SERV graphs, and makes them super consistent and lightning fast, lowering the overall cost and latency of graph execution. SERV Reasoning on its own is a great force multiplier for Jev because, like all other models, it works by interpreting input instructions. The clearer those instructions are, the better the model performs. That's where SERV Reasoning comes into play. Just like amplifying any other model, we also amplify the accuracy and consistency of Jev's responses. And now we're bringing Jev-powered Decision nodes into Graph Sharding with SERV v3.

Armagan Amcalar

365,108 views • 5 days ago

Stop manually making flowcharts. Try this GitHub skill with Claude Code. I found an open-source tool that turns a plain description of a software system into a clean, interactive diagram. It's called Archify, and it has more than 66,000 stars on GitHub. You add it as a skill to an AI coding agent like Claude Code, Codex, Cursor, or OpenCode. Then you describe the system in the chat in one line. Archify turns that line into a single HTML file you can open, click through, and send to anyone. If you point your agent at an existing codebase, it reads the code and Archify maps how the pieces connect. I liked five things about it. 1. It makes five kinds of diagrams, including system maps and step-by-step workflows. 2. You can click any piece and trace what connects to it. 3. It checks the layout before it hands the diagram over, so arrows don't pile up and labels don't overlap. 4. It has dark and light themes and exports to PNG, SVG, or a short video. 5. You keep editing in plain chat, with requests like "add Redis" or "highlight the rollback path." You don't need a codebase to use it. A description in the chat is enough.
0:12

Stop manually making flowcharts. Try this GitHub skill with Claude Code. I found an open-source tool that turns a plain description of a software system into a clean, interactive diagram. It's called Archify, and it has more than 66,000 stars on GitHub. You add it as a skill to an AI coding agent like Claude Code, Codex, Cursor, or OpenCode. Then you describe the system in the chat in one line. Archify turns that line into a single HTML file you can open, click through, and send to anyone. If you point your agent at an existing codebase, it reads the code and Archify maps how the pieces connect. I liked five things about it. 1. It makes five kinds of diagrams, including system maps and step-by-step workflows. 2. You can click any piece and trace what connects to it. 3. It checks the layout before it hands the diagram over, so arrows don't pile up and labels don't overlap. 4. It has dark and light themes and exports to PNG, SVG, or a short video. 5. You keep editing in plain chat, with requests like "add Redis" or "highlight the rollback path." You don't need a codebase to use it. A description in the chat is enough.

Alex Veremeyenko

52,933 views • 9 days ago

Jev + Muse is the first AI agent system that actually automate 100% of my life 99% of people pay 200x more for slower AI agents - while 1% run this 2030 setup just 5 min and setup is ready: prompt → Muse → Jev decision → Muse execution → result step 1 → create your Jev API key (typesafe website) step 2 → clone and install the complete router from Github below python3 -m venv .venv && .venv/bin/pip install -r requirements.txt && cp config.example.yaml config.yaml step 3 → export the key before running anything: export TYPESAFE_API_KEY='YOUR_KEY' add the same export to ~/.zshrc or ~/.bashrc if you want it to survive a new terminal session step 4 → give your agent skill/jev-decision-layer.SKILL.md and connect it to src/router.py + recipes/ , raw Jev returns probabilities - the router converts them into executable actions step 5 → test the entire chain, not the raw Jev API: .venv/bin/python -m src.cli '{"goal":"what is 2+2?","kind":"chat"}' the final JSON should contain action, reason, mode, jev_used and confidence details step 6 → keep mode: shadow for 20–50 real decisions: the agent works normally while Jev’s routes are logged and checked; promote only reliable question packs step 7 → switch to mode: active with hard confidence gates: ≥0.80 act automatically, 0.50–0.79 advisory only, <0.50 escalate to the human the result: Jev + Muse is a system that decides what to do, what to skip and when to bring in - I’ve tested it across my daily workflows, and it’s the best setup I’ve found for automating routine Take the exact stack I built, run it yourself from the repo - then read the full Jev architecture behind it ↓
0:16

Jev + Muse is the first AI agent system that actually automate 100% of my life 99% of people pay 200x more for slower AI agents - while 1% run this 2030 setup just 5 min and setup is ready: prompt → Muse → Jev decision → Muse execution → result step 1 → create your Jev API key (typesafe website) step 2 → clone and install the complete router from Github below python3 -m venv .venv && .venv/bin/pip install -r requirements.txt && cp config.example.yaml config.yaml step 3 → export the key before running anything: export TYPESAFE_API_KEY='YOUR_KEY' add the same export to ~/.zshrc or ~/.bashrc if you want it to survive a new terminal session step 4 → give your agent skill/jev-decision-layer.SKILL.md and connect it to src/router.py + recipes/ , raw Jev returns probabilities - the router converts them into executable actions step 5 → test the entire chain, not the raw Jev API: .venv/bin/python -m src.cli '{"goal":"what is 2+2?","kind":"chat"}' the final JSON should contain action, reason, mode, jev_used and confidence details step 6 → keep mode: shadow for 20–50 real decisions: the agent works normally while Jev’s routes are logged and checked; promote only reliable question packs step 7 → switch to mode: active with hard confidence gates: ≥0.80 act automatically, 0.50–0.79 advisory only, <0.50 escalate to the human the result: Jev + Muse is a system that decides what to do, what to skip and when to bring in - I’ve tested it across my daily workflows, and it’s the best setup I’ve found for automating routine Take the exact stack I built, run it yourself from the repo - then read the full Jev architecture behind it ↓

codila

91,306 views • 6 days ago

Jev + GrokBot is the best GTM system I've ever built It just made my GTM x200 CHEAPER and x400 FASTER than what 95% of teams are running... setup takes literally 9 minutes: prompt → GrokBot → Jev routes every candidate → GrokBot opens only survivors → campaign step 1 → open TypeSafe AI, create API key (keep it off chat paste) step 2 → tell GrokBot: store TYPESAFE_API_KEY in the secure field step 3 → prompt GrokBot: install typesafe-sdk on Agent Computer + smoke system_one (Choice) step 4 → point it at a target: "read end to end, pull positioning, ICP, every proof point. no copy yet" step 5 → add skill gtm-router: every candidate from X / LinkedIn / YouTube gets 6 typed questions → CHEAP SKIP / OPEN FULL / FLAG KOL step 6 → let Jev rank hook archetypes by viral rate, not by how often people post them - this is where the whole playbook comes from step 7 → GrokBot assembles the KOL shortlist and the 7-day plan - you stay in control of anything irreversible the result: → 3,412 candidates, X, LinkedIn and YouTube. → 15.7 seconds. $0.41. → me doing the same reading: 6h 12m. 8 grok bots brief it, Jev decides, GrokBot executes. no fine-tuning, no embeddings, no vector db - 6 typed questions and a schema. Setup your GrokBot JEV GTM today, then read the article below to learn how to build an agent team with JEV.
0:17

Jev + GrokBot is the best GTM system I've ever built It just made my GTM x200 CHEAPER and x400 FASTER than what 95% of teams are running... setup takes literally 9 minutes: prompt → GrokBot → Jev routes every candidate → GrokBot opens only survivors → campaign step 1 → open TypeSafe AI, create API key (keep it off chat paste) step 2 → tell GrokBot: store TYPESAFE_API_KEY in the secure field step 3 → prompt GrokBot: install typesafe-sdk on Agent Computer + smoke system_one (Choice) step 4 → point it at a target: "read end to end, pull positioning, ICP, every proof point. no copy yet" step 5 → add skill gtm-router: every candidate from X / LinkedIn / YouTube gets 6 typed questions → CHEAP SKIP / OPEN FULL / FLAG KOL step 6 → let Jev rank hook archetypes by viral rate, not by how often people post them - this is where the whole playbook comes from step 7 → GrokBot assembles the KOL shortlist and the 7-day plan - you stay in control of anything irreversible the result: → 3,412 candidates, X, LinkedIn and YouTube. → 15.7 seconds. $0.41. → me doing the same reading: 6h 12m. 8 grok bots brief it, Jev decides, GrokBot executes. no fine-tuning, no embeddings, no vector db - 6 typed questions and a schema. Setup your GrokBot JEV GTM today, then read the article below to learn how to build an agent team with JEV.

Movez

85,453 views • 8 days ago

New open-source agent harness just landed! I got early access to TrueForge by TrueFoundry and have been running it locally for the past few days. The harness layer deserves as much attention as the model, and open source matters here because you can inspect the loop, run it on your own infrastructure, and swap to the latest or cheaper models. TrueForge handles the runtime work that makes an agent reliable. It drives the tool-calling loop, manages context, coordinates subagents, and executes code in a sandbox, with any model you choose. Every tool call re-sends the growing context to the model, so in practice the harness controls most of what an agent costs to run. A few things stood out from my testing and their published benchmarks. Vendor-Neutral by design. It runs OpenAI, Anthropic, and Google models alongside open-weight models like Kimi, GLM, and DeepSeek. Model routing is a setting, and you can send each task to the model that fits it. On a 14-task enterprise agent benchmark, it matched the accuracy of Claude Managed Agents running the same Opus 4.8 model at roughly 30% lower cost per run (3.8M tokens vs 10M for the same answers). Routing the same tasks to GLM-5.2 held accuracy and brought cost down by about 75%, around $3 per run instead of $12. Fully self-hosted and Open Source (MIT License). I had it running locally with one command, with sandboxed code execution working out of the box. It's time to own your agent harness. Thanks to TrueFoundry for partnering on this post.
0:16

New open-source agent harness just landed! I got early access to TrueForge by TrueFoundry and have been running it locally for the past few days. The harness layer deserves as much attention as the model, and open source matters here because you can inspect the loop, run it on your own infrastructure, and swap to the latest or cheaper models. TrueForge handles the runtime work that makes an agent reliable. It drives the tool-calling loop, manages context, coordinates subagents, and executes code in a sandbox, with any model you choose. Every tool call re-sends the growing context to the model, so in practice the harness controls most of what an agent costs to run. A few things stood out from my testing and their published benchmarks. Vendor-Neutral by design. It runs OpenAI, Anthropic, and Google models alongside open-weight models like Kimi, GLM, and DeepSeek. Model routing is a setting, and you can send each task to the model that fits it. On a 14-task enterprise agent benchmark, it matched the accuracy of Claude Managed Agents running the same Opus 4.8 model at roughly 30% lower cost per run (3.8M tokens vs 10M for the same answers). Routing the same tasks to GLM-5.2 held accuracy and brought cost down by about 75%, around $3 per run instead of $12. Fully self-hosted and Open Source (MIT License). I had it running locally with one command, with sandboxed code execution working out of the box. It's time to own your agent harness. Thanks to TrueFoundry for partnering on this post.

elvis

11,303 views • 1 month ago

One of the craziest use cases I’ve found for Jev: verifiers. I am so excited about this that I at least wanted to share the high-level idea. I used Jev to build a custom verifier for the /goal feature in my agent harness. It checks whether the goal is actually complete after every turn, making continuous verification cheap enough to scale. This means I can run more of these verifiers (previously handled by another expensive reasoning model) more frequently to keep the agents on track. System One models are perfect for verification. I think of this as scaling harnesses further by cleverly combining System One and System Two models. I have a feeling this will enable a new wave of scalable test-time compute methods. Watch this space closely. I've just started to experiment with this and am already seeing really good results. I need to explore and figure out a way to benchmark it. I will share more once I have more results. This is an insane unlock for long-horizon agents. You heard it here first. And you can expect to see more harnesses embracing this new pattern. Full guide dropping in the next couple of days.
0:17

One of the craziest use cases I’ve found for Jev: verifiers. I am so excited about this that I at least wanted to share the high-level idea. I used Jev to build a custom verifier for the /goal feature in my agent harness. It checks whether the goal is actually complete after every turn, making continuous verification cheap enough to scale. This means I can run more of these verifiers (previously handled by another expensive reasoning model) more frequently to keep the agents on track. System One models are perfect for verification. I think of this as scaling harnesses further by cleverly combining System One and System Two models. I have a feeling this will enable a new wave of scalable test-time compute methods. Watch this space closely. I've just started to experiment with this and am already seeing really good results. I need to explore and figure out a way to benchmark it. I will share more once I have more results. This is an insane unlock for long-horizon agents. You heard it here first. And you can expect to see more harnesses embracing this new pattern. Full guide dropping in the next couple of days.

elvis

58,818 views • 9 days ago

Stanford researchers did it again. They just built the agent-native version of Git. When an agent works on a longer task, the run builds up a lot of state. This includes files edited/created, a dev server, a database, installed packages, KV cache, etc. Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine. The tests start failing, and the run goes off track, although everything through step eight was correct. By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context. The other options are a person stepping in to redirect it or restarting the whole run from step one. That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway. The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log. It records what the agent said and which tools it called, but not the live state underneath. That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log. Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache. Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log. Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run. Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files. Going back to a previous step is then a single call that forks from that commit and continues from the exact state. The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again. Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed. In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness. Not everything is reversible though. Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance. Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires. They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%. It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time. If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run. Shepherd Repo: (don't forget to star it ⭐ ) That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change. Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur. Read it below.
0:15

Stanford researchers did it again. They just built the agent-native version of Git. When an agent works on a longer task, the run builds up a lot of state. This includes files edited/created, a dev server, a database, installed packages, KV cache, etc. Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine. The tests start failing, and the run goes off track, although everything through step eight was correct. By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context. The other options are a person stepping in to redirect it or restarting the whole run from step one. That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway. The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log. It records what the agent said and which tools it called, but not the live state underneath. That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log. Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache. Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log. Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run. Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files. Going back to a previous step is then a single call that forks from that commit and continues from the exact state. The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again. Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed. In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness. Not everything is reversible though. Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance. Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires. They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%. It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time. If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run. Shepherd Repo: (don't forget to star it ⭐ ) That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change. Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur. Read it below.

Avi Chawla

441,974 views • 2 months ago

Another WTF moment. A developer just open-sourced a coding agent harness that boots 245x faster than Claude Code. It's called jcode. You launch it and the first frame renders in 14 milliseconds. Claude Code takes 3,436. One active session uses 27.8 MB of RAM. Claude Code uses 386.6. Run ten sessions in parallel and jcode holds at 117 MB while OpenCode swells to 3.2 GB. Each agent has a semantic memory graph instead of a scratchpad. Every turn gets embedded as a vector. The graph is queried on every turn for related memories, and a sideagent verifies the hits before injecting them into context. Consolidation runs in the background to check for stale or conflicting facts. No manual /remember calls. No token burn on lookup tools. The provider list is 30+ deep. Claude, ChatGPT, Gemini, GitHub Copilot, Azure, OpenRouter, DeepSeek, Groq, Mistral, Perplexity, Fireworks, Ollama, LM Studio, and any OpenAI-compatible endpoint you point it at. Ran out of tokens on your first ChatGPT Pro sub? /account swaps to the second. Then there's Swarm. Spawn two agents in the same repo and the server manages them. When agent A edits a file agent B has been reading, agent B gets pinged and can check the diff. Agents can DM each other, broadcast to the room, or spawn their own worker teams for parallel tasks. Groups, channels, and completion statuses are handled automatically. The UI has live side panels that render mermaid diagrams inline. To make it fast, the author wrote a Rust mermaid renderer 1800x faster than the JavaScript one, then wrote a custom terminal called Handterm because no existing terminal could do smooth partial-line scrolling. Self-dev mode is where it gets wild. Tell your agent to enter self-dev and it starts editing jcode's own source code, rebuilds the binary, reloads it live, and keeps working across your existing sessions. You can also resume broken sessions from Claude Code, Codex, OpenCode, or pi directly inside jcode. Anthropic's cache goes cold at the 5-minute mark and you're staring down a big cache miss on your next turn? The UI warns you before you spend the tokens. Written in Rust. MIT licensed. Runs on macOS, Windows, Linux, and Termux. Sitting at 11.2k stars with a native iOS app coming.
0:17

Another WTF moment. A developer just open-sourced a coding agent harness that boots 245x faster than Claude Code. It's called jcode. You launch it and the first frame renders in 14 milliseconds. Claude Code takes 3,436. One active session uses 27.8 MB of RAM. Claude Code uses 386.6. Run ten sessions in parallel and jcode holds at 117 MB while OpenCode swells to 3.2 GB. Each agent has a semantic memory graph instead of a scratchpad. Every turn gets embedded as a vector. The graph is queried on every turn for related memories, and a sideagent verifies the hits before injecting them into context. Consolidation runs in the background to check for stale or conflicting facts. No manual /remember calls. No token burn on lookup tools. The provider list is 30+ deep. Claude, ChatGPT, Gemini, GitHub Copilot, Azure, OpenRouter, DeepSeek, Groq, Mistral, Perplexity, Fireworks, Ollama, LM Studio, and any OpenAI-compatible endpoint you point it at. Ran out of tokens on your first ChatGPT Pro sub? /account swaps to the second. Then there's Swarm. Spawn two agents in the same repo and the server manages them. When agent A edits a file agent B has been reading, agent B gets pinged and can check the diff. Agents can DM each other, broadcast to the room, or spawn their own worker teams for parallel tasks. Groups, channels, and completion statuses are handled automatically. The UI has live side panels that render mermaid diagrams inline. To make it fast, the author wrote a Rust mermaid renderer 1800x faster than the JavaScript one, then wrote a custom terminal called Handterm because no existing terminal could do smooth partial-line scrolling. Self-dev mode is where it gets wild. Tell your agent to enter self-dev and it starts editing jcode's own source code, rebuilds the binary, reloads it live, and keeps working across your existing sessions. You can also resume broken sessions from Claude Code, Codex, OpenCode, or pi directly inside jcode. Anthropic's cache goes cold at the 5-minute mark and you're staring down a big cache miss on your next turn? The UI warns you before you spend the tokens. Written in Rust. MIT licensed. Runs on macOS, Windows, Linux, and Termux. Sitting at 11.2k stars with a native iOS app coming.

Brady Long

208,693 views • 2 months ago

this is f*cking beyond comprehension. Google engineers just shipped the entire agent lifecycle in one release: build, scale, govern. and every piece answers a specific way agents die in production > context layers (Static, Turn, User, Cache): you decide what the model carries between turns, so token spend stops being a mystery > a self heal plugin: the agent notices a tool call failed and retries it a different way instead of dying mid run > adk deploy: one command from your laptop to the managed runtime, no packaging, no infra ticket > Go joins Python and Java, with its own A2A SDK then the part nobody builds for themselves: > a dashboard on token consumption, latency, error rates and tool calls: the four things that actually kill an agent > a traces tab that opens the real sequence of actions the agent took, step by step > a playground wired to the deployed agent, past sessions included, so debugging is not a redeploy loop > an Evaluation Layer with a User Simulator, because you cannot unit test a non deterministic system and the part that decides whether it ever ships: > agents get native identities as first class IAM principals: least privilege applies to them like it does to people > Model Armor screens prompt injection, tool calls and responses, inline for Gemini or over REST > Security Command Center inventories every agentic asset and flags data exfiltration by an agent ADK is already at 7 million downloads. the runtime has a free tier, and express mode runs off a Gmail address. the prototype was never the hard part.
0:19

this is f*cking beyond comprehension. Google engineers just shipped the entire agent lifecycle in one release: build, scale, govern. and every piece answers a specific way agents die in production > context layers (Static, Turn, User, Cache): you decide what the model carries between turns, so token spend stops being a mystery > a self heal plugin: the agent notices a tool call failed and retries it a different way instead of dying mid run > adk deploy: one command from your laptop to the managed runtime, no packaging, no infra ticket > Go joins Python and Java, with its own A2A SDK then the part nobody builds for themselves: > a dashboard on token consumption, latency, error rates and tool calls: the four things that actually kill an agent > a traces tab that opens the real sequence of actions the agent took, step by step > a playground wired to the deployed agent, past sessions included, so debugging is not a redeploy loop > an Evaluation Layer with a User Simulator, because you cannot unit test a non deterministic system and the part that decides whether it ever ships: > agents get native identities as first class IAM principals: least privilege applies to them like it does to people > Model Armor screens prompt injection, tool calls and responses, inline for Gemini or over REST > Security Command Center inventories every agentic asset and flags data exfiltration by an agent ADK is already at 7 million downloads. the runtime has a free tier, and express mode runs off a Gmail address. the prototype was never the hard part.

NO1ennn

24,666 views • 12 days ago

I just built a Meta Ads diagnostic in Claude Code that tells you WHY your account broke, not just what changed 🤯 It spins up a team of agents that each investigate a different reason performance dropped, then argue against each other to kill the wrong answer before it ever reaches you. All inside Claude Code. Perfect for DTC brands and agencies who panic-kill creative the second CPA spikes. If you've watched ROAS fall off a cliff and opened Ads Manager with ten tabs going, you already know what happens next. Your gut says "creative fatigue." You kill your best-performing ad. A week later performance is still broken, because that was never the problem. Guessing wrong is the most expensive move in paid social. This workflow ends the guessing: → One agent investigates each competing theory — creative fatigue, budget and delivery changes, traffic quality, offer and seasonality → Each one is blind to the others, reasoning only from its own slice of the data so they can't bias each other → A refuter agent then attacks every surviving theory and tries to kill it → A theory only stands if the data can't disprove it → You get a ranked diagnosis: the real cause, the evidence for and against it, and the one move to make this week No anchoring on the first obvious answer. No killing winning creative on a hunch. No "here's what happened" reports that never tell you why. What you get: → Every theory tested in parallel instead of one biased guess → An adversarial pass that kills the wrong answer before you act on it → A ranked diagnosis with confidence levels and evidence both ways → A reusable workflow you drop next month's export into and re-run Built 100% in Claude Code with the new dynamic workflows. The first account I ran it on looked like textbook creative fatigue. The workflow disagreed, and traced the real cause to a budget change that had doubled spend and flooded delivery with junk traffic. I put together a full playbook with the exact workflow, the prompt, and how to run it on your own account. Want it for free? > Like this post > Comment "META" And I'll send it over (must be following so I can DM)
0:19

I just built a Meta Ads diagnostic in Claude Code that tells you WHY your account broke, not just what changed 🤯 It spins up a team of agents that each investigate a different reason performance dropped, then argue against each other to kill the wrong answer before it ever reaches you. All inside Claude Code. Perfect for DTC brands and agencies who panic-kill creative the second CPA spikes. If you've watched ROAS fall off a cliff and opened Ads Manager with ten tabs going, you already know what happens next. Your gut says "creative fatigue." You kill your best-performing ad. A week later performance is still broken, because that was never the problem. Guessing wrong is the most expensive move in paid social. This workflow ends the guessing: → One agent investigates each competing theory — creative fatigue, budget and delivery changes, traffic quality, offer and seasonality → Each one is blind to the others, reasoning only from its own slice of the data so they can't bias each other → A refuter agent then attacks every surviving theory and tries to kill it → A theory only stands if the data can't disprove it → You get a ranked diagnosis: the real cause, the evidence for and against it, and the one move to make this week No anchoring on the first obvious answer. No killing winning creative on a hunch. No "here's what happened" reports that never tell you why. What you get: → Every theory tested in parallel instead of one biased guess → An adversarial pass that kills the wrong answer before you act on it → A ranked diagnosis with confidence levels and evidence both ways → A reusable workflow you drop next month's export into and re-run Built 100% in Claude Code with the new dynamic workflows. The first account I ran it on looked like textbook creative fatigue. The workflow disagreed, and traced the real cause to a budget change that had doubled spend and flooded delivery with junk traffic. I put together a full playbook with the exact workflow, the prompt, and how to run it on your own account. Want it for free? > Like this post > Comment "META" And I'll send it over (must be following so I can DM)

Mike Futia

12,875 views • 3 months ago

HydraFusion Explained. Part I: How does the Copilot engine know what to optimize for? Your prompt is evaluated across 4 dimensions: ➡ Does it require deep reasoning? (aka. reasoning depth) ➡ Is it a sophisticated problem? (aka. code generation complexity) ➡ Is it untangling a complicated mess? (aka. debugging difficulty) ➡ Is it dominated by tool-use? (aka. tool orchestration needs) Based on this evaluation, a HyDRA score is assigned to determine the capability profile your task needs the most and to establish a quality bar. Part II: How does it choose a model? Note: It doesn' t pick one model to handle the entire job e2e, (that's Auto mode). Instead, it selects 1 of 3 execution workflows and assigns the best model at different stages based on the HyDRA score: 1️⃣ Single ⚙️ How it works: A single model completes the task from start to finish. ⚖️ Rationale: The task comfortably meets the quality bar with one model. Multi-model orchestration would add latency and cost with no meaningful quality gain. 2️⃣ Cascade ⚙️ How it works: A lightweight, cost-efficient model generates the solution. This draft is evaluated against a quality gate and if it falls short of the quality bar, the entire task escalates to a stronger, frontier model. ⚖️ Rationale: Only bring in the big guns when there is concrete evidence that a lightweight model won't meet the quality threshold. 3️⃣ Critique ⚙️ How it works: A lightweight model drafts the initial code and tool interactions. An independent, read-only frontier model reviews that draft and provides feedback. The original lightweight model then performs any targeted revision(s) before the final response is sent to the user. ⚖️ Rationale: Writing code (output tokens) is expensive while reviewing code (input tokens) is cheap. Instead of incurring the cost of a powerhouse writing hundreds of lines from scratch, a cost-efficient model writes the first draft, and the frontier model just reviews it and points out fixes. HydraFusion is available in experimental preview on the GitHub Copilot CLI: /experimental on, /model and select Hydrafusion (Research Preview)
0:13

HydraFusion Explained. Part I: How does the Copilot engine know what to optimize for? Your prompt is evaluated across 4 dimensions: ➡ Does it require deep reasoning? (aka. reasoning depth) ➡ Is it a sophisticated problem? (aka. code generation complexity) ➡ Is it untangling a complicated mess? (aka. debugging difficulty) ➡ Is it dominated by tool-use? (aka. tool orchestration needs) Based on this evaluation, a HyDRA score is assigned to determine the capability profile your task needs the most and to establish a quality bar. Part II: How does it choose a model? Note: It doesn' t pick one model to handle the entire job e2e, (that's Auto mode). Instead, it selects 1 of 3 execution workflows and assigns the best model at different stages based on the HyDRA score: 1️⃣ Single ⚙️ How it works: A single model completes the task from start to finish. ⚖️ Rationale: The task comfortably meets the quality bar with one model. Multi-model orchestration would add latency and cost with no meaningful quality gain. 2️⃣ Cascade ⚙️ How it works: A lightweight, cost-efficient model generates the solution. This draft is evaluated against a quality gate and if it falls short of the quality bar, the entire task escalates to a stronger, frontier model. ⚖️ Rationale: Only bring in the big guns when there is concrete evidence that a lightweight model won't meet the quality threshold. 3️⃣ Critique ⚙️ How it works: A lightweight model drafts the initial code and tool interactions. An independent, read-only frontier model reviews that draft and provides feedback. The original lightweight model then performs any targeted revision(s) before the final response is sent to the user. ⚖️ Rationale: Writing code (output tokens) is expensive while reviewing code (input tokens) is cheap. Instead of incurring the cost of a powerhouse writing hundreds of lines from scratch, a cost-efficient model writes the first draft, and the frontier model just reviews it and points out fixes. HydraFusion is available in experimental preview on the GitHub Copilot CLI: /experimental on, /model and select Hydrafusion (Research Preview)

Julia Muiruri

12,687 views • 20 days ago

I built HypeMeter in 4 hours with Jev + Minds. Its best trick is saying no, and deciding what is likely a rug vs real hype. I am giving away an Argonaut NFT to reward Beta testers. Yes, that's you. Every "alpha bot" screams BUY. None of them tell you which cheap listings are cheap for a reason. So I wired two things together: Jev by TypeSafe AI . It does not write essays. It answers typed questions: pick one, score this, yes or no. About a third of a second per decision, cheap enough to judge every cheap listing instead of a shortlist. Minds by Minds by Animoca Brands . Your own AI agent. Tell it your strategy in plain words ("Argonauts under 0.3, grade A or better") and it messages you one digest a day, pings you whenever steals are available. First full sweep: 898 listings across 20 collections, including Robinhood (of course). Calls that survived: one. And that one was my own bug: an "83% edge" that was a 2-item bid read as one. The sanity check now kills those before anyone sees them. That is the product. Most cheap NFTs are traps, and it says so. It also hunts rares priced under what their trait actually sells for. Yesterday it flagged an Argonaut with a 1-in-70 palette, listed at 0.79 ETH two days before the same palette sold for 0.9 and 1.0. No hindsight. Every call is written down the moment it is made, then graded at 24 hours and 7 days. Public scoreboard, losses included. Free while in beta. Sign in with Minds: And yes, the giveaway is real: Argonaut #2764 goes to someone who actually uses it. Every active day is an entry, there is a leaderboard, and signing in before 24 Sept gets you 3 bonus entries. Rules on the site. RT and comment "Jev" for extra entry. Have fun sniping.
0:14

I built HypeMeter in 4 hours with Jev + Minds. Its best trick is saying no, and deciding what is likely a rug vs real hype. I am giving away an Argonaut NFT to reward Beta testers. Yes, that's you. Every "alpha bot" screams BUY. None of them tell you which cheap listings are cheap for a reason. So I wired two things together: Jev by TypeSafe AI . It does not write essays. It answers typed questions: pick one, score this, yes or no. About a third of a second per decision, cheap enough to judge every cheap listing instead of a shortlist. Minds by Minds by Animoca Brands . Your own AI agent. Tell it your strategy in plain words ("Argonauts under 0.3, grade A or better") and it messages you one digest a day, pings you whenever steals are available. First full sweep: 898 listings across 20 collections, including Robinhood (of course). Calls that survived: one. And that one was my own bug: an "83% edge" that was a 2-item bid read as one. The sanity check now kills those before anyone sees them. That is the product. Most cheap NFTs are traps, and it says so. It also hunts rares priced under what their trait actually sells for. Yesterday it flagged an Argonaut with a 1-in-70 palette, listed at 0.79 ETH two days before the same palette sold for 0.9 and 1.0. No hindsight. Every call is written down the moment it is made, then graded at 24 hours and 7 days. Public scoreboard, losses included. Free while in beta. Sign in with Minds: And yes, the giveaway is real: Argonaut #2764 goes to someone who actually uses it. Every active day is an entry, there is a leaderboard, and signing in before 24 Sept gets you 3 bonus entries. Rules on the site. RT and comment "Jev" for extra entry. Have fun sniping.

Jesus is Lord | Chev

44,602 views • 6 days ago

OpenAI's AgentKit will be so insane, build every step of agents on one platform. These visual agent builders make the whole process of iterating and launching agents far more efficient. It sits on top of the Responses API and unifies the tools that were previously scattered across SDKs and custom orchestration. It lets developers create agent workflows visually, connect data sources securely, and measure performance automatically without coding every layer by hand. The core of AgentKit is the Agent Builder, a drag-and-drop canvas where each node represents an action, guardrail, or decision branch. Developers can link these nodes into multi-agent workflows, preview results instantly, and version each setup. It supports inline evaluation so that developers can see how changes affect output before deploying. The Connector Registry is a single admin panel that manages how data and tools connect across the OpenAI ecosystem. It centralizes integrations like Google Drive, SharePoint, Dropbox, and Microsoft Teams. Large organizations can govern access and flow of data between agents securely under one global console. ChatKit provides a ready-to-use chat interface for embedding agents inside apps or websites. It manages streaming, message threads, and model reasoning displays automatically. Developers can skin the interface to match their product without writing custom front-end code. Under the hood, all these blocks use the same execution core that runs agent reasoning through OpenAI’s APIs. Workflows in Agent Builder compile down to structured instructions for the Responses API, which handles model calls, tool use, and context passing. Connector Registry handles authentication and routing for external tools, while Evals and RFT provide feedback loops that improve agents over time. This integration means developers no longer need to handle orchestration logic, model evaluation pipelines, or safety layers separately. Everything runs natively within OpenAI’s control plane with managed security, automatic versioning, and built-in testing. In short, AgentKit standardizes the entire life cycle of an AI agent—from visual design to deployment and performance tuning—inside a single unified system.
0:10

OpenAI's AgentKit will be so insane, build every step of agents on one platform. These visual agent builders make the whole process of iterating and launching agents far more efficient. It sits on top of the Responses API and unifies the tools that were previously scattered across SDKs and custom orchestration. It lets developers create agent workflows visually, connect data sources securely, and measure performance automatically without coding every layer by hand. The core of AgentKit is the Agent Builder, a drag-and-drop canvas where each node represents an action, guardrail, or decision branch. Developers can link these nodes into multi-agent workflows, preview results instantly, and version each setup. It supports inline evaluation so that developers can see how changes affect output before deploying. The Connector Registry is a single admin panel that manages how data and tools connect across the OpenAI ecosystem. It centralizes integrations like Google Drive, SharePoint, Dropbox, and Microsoft Teams. Large organizations can govern access and flow of data between agents securely under one global console. ChatKit provides a ready-to-use chat interface for embedding agents inside apps or websites. It manages streaming, message threads, and model reasoning displays automatically. Developers can skin the interface to match their product without writing custom front-end code. Under the hood, all these blocks use the same execution core that runs agent reasoning through OpenAI’s APIs. Workflows in Agent Builder compile down to structured instructions for the Responses API, which handles model calls, tool use, and context passing. Connector Registry handles authentication and routing for external tools, while Evals and RFT provide feedback loops that improve agents over time. This integration means developers no longer need to handle orchestration logic, model evaluation pipelines, or safety layers separately. Everything runs natively within OpenAI’s control plane with managed security, automatic versioning, and built-in testing. In short, AgentKit standardizes the entire life cycle of an AI agent—from visual design to deployment and performance tuning—inside a single unified system.

Rohan Paul

178,460 views • 11 months ago

whoever leaked this has bigger balls than sense Google Research and MIT ran the same agent jobs 260 different ways for Nature last month: they held the prompts, the tools and the compute budget identical and moved nothing but the wiring between the agents, and the same work swung from 70% worse than a single agent to 80.8% better, averaging out at 0.0% i ran my own single agent against the task list first and it cleared 6 of 10 alone, already past the line where a crew starts subtracting this is Graph Engineering, the layer that decides whether a crew is worth 80% more or 70% less, and it installs into the agent you already pay for: - score your solo agent on the real task first: above roughly 45% success that study predicts zero to negative returns from any crew you put around it - under that line, put one supervisor over the fan out: crews with no correction step amplified their own errors to 17.2x the single agent rate, supervised aggregation held it to 4.4x - give every worker one output and let none of them read a peer's draft, so a wrong step reaches the supervisor instead of four other agents - run the comparison again after every model upgrade, because a better model raises your baseline and a higher baseline is what makes a crew stop paying - keep the single agent alive as the control, the only number that says the wiring is earning its calls turns out the shape does not travel: the biggest win came off a finance task under one supervisor and the worst collapse off a planning task with independent agents my position, and it is the arguable one: a crew is a bet on your own diagram, and the model you pick moves that bet less than one arrow does bookmark this, the three moves that draw those arrows before you pay for one extra call are in the post below ↓
0:15

whoever leaked this has bigger balls than sense Google Research and MIT ran the same agent jobs 260 different ways for Nature last month: they held the prompts, the tools and the compute budget identical and moved nothing but the wiring between the agents, and the same work swung from 70% worse than a single agent to 80.8% better, averaging out at 0.0% i ran my own single agent against the task list first and it cleared 6 of 10 alone, already past the line where a crew starts subtracting this is Graph Engineering, the layer that decides whether a crew is worth 80% more or 70% less, and it installs into the agent you already pay for: - score your solo agent on the real task first: above roughly 45% success that study predicts zero to negative returns from any crew you put around it - under that line, put one supervisor over the fan out: crews with no correction step amplified their own errors to 17.2x the single agent rate, supervised aggregation held it to 4.4x - give every worker one output and let none of them read a peer's draft, so a wrong step reaches the supervisor instead of four other agents - run the comparison again after every model upgrade, because a better model raises your baseline and a higher baseline is what makes a crew stop paying - keep the single agent alive as the control, the only number that says the wiring is earning its calls turns out the shape does not travel: the biggest win came off a finance task under one supervisor and the worst collapse off a planning task with independent agents my position, and it is the arguable one: a crew is a bet on your own diagram, and the model you pick moves that bet less than one arrow does bookmark this, the three moves that draw those arrows before you pay for one extra call are in the post below ↓

Argona

891,866 views • 1 month ago

this is worth more than most five figure courses 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓
0:15

this is worth more than most five figure courses 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓

Argona

157,312 views • 2 months ago

Making OpenCode as lean as Pi agent? Just trimmed 25k out of OpenCode's system prompt (from 30k to 4-5k tokens) How? Just disable skills and get rid of massive skill definition bloat. Who needs skills anyway? Just kidding, this is the not the way. It makes the agent lame and defeats the point of using one. But it sets a precedent: Find a way to use skills without their definitions pre-loaded into the system prompt every single turn. Another interesting stuff: Upon testing this temporary "no skill setup" with two of hottest OpenCode Zen free models, Mimo V2.5 vs DeepSeek V4 Flash: One thinks more and talks less One thinks less and talks more Check the video to see which is which If you made it here, I'm finding a way to leanest OpenCode setup that I can get I simply don't believe that OpenCode can't be as lean as Pi Upon tinkering, I made a plugin that temporarily extracts the system prompt while I test, and noticed the hundreds of definitions in it from my .agents/skills directory which is shared across all my coding agents (Cursor, Antigravity, Claude, etc.) Of course disabling skills is not the answer, but it just proved that there is a way to strip the system prompt of these massive skill defs Aside from the system prompt hierarchy that injects confusion imo if you have a conflicting and redundant AGENTS.md which I discovered upon digging into OpenCode's source code Apparently it has prompt.ts/system.ts/instruction.ts/llm.ts and loads base .txt prompts based on model family (claude/gpt-o/gpt-5/codex/gemini/others) that all work together to make OpenCode aware of who it was and how it should use tools and become a "coding agent" Gotta find the most minimal mix that fits right into my workflow Make OpenCode as lean as Pi? We'll see. All in
0:11

Making OpenCode as lean as Pi agent? Just trimmed 25k out of OpenCode's system prompt (from 30k to 4-5k tokens) How? Just disable skills and get rid of massive skill definition bloat. Who needs skills anyway? Just kidding, this is the not the way. It makes the agent lame and defeats the point of using one. But it sets a precedent: Find a way to use skills without their definitions pre-loaded into the system prompt every single turn. Another interesting stuff: Upon testing this temporary "no skill setup" with two of hottest OpenCode Zen free models, Mimo V2.5 vs DeepSeek V4 Flash: One thinks more and talks less One thinks less and talks more Check the video to see which is which If you made it here, I'm finding a way to leanest OpenCode setup that I can get I simply don't believe that OpenCode can't be as lean as Pi Upon tinkering, I made a plugin that temporarily extracts the system prompt while I test, and noticed the hundreds of definitions in it from my .agents/skills directory which is shared across all my coding agents (Cursor, Antigravity, Claude, etc.) Of course disabling skills is not the answer, but it just proved that there is a way to strip the system prompt of these massive skill defs Aside from the system prompt hierarchy that injects confusion imo if you have a conflicting and redundant AGENTS.md which I discovered upon digging into OpenCode's source code Apparently it has prompt.ts/system.ts/instruction.ts/llm.ts and loads base .txt prompts based on model family (claude/gpt-o/gpt-5/codex/gemini/others) that all work together to make OpenCode aware of who it was and how it should use tools and become a "coding agent" Gotta find the most minimal mix that fits right into my workflow Make OpenCode as lean as Pi? We'll see. All in

raymel 👋

37,939 views • 4 months ago

Don't train the model, evolve the harness. I read a brilliant blog post from Hugging Face where they took a frozen open model scoring 0% on a hard legal agent benchmark, left its weights alone, and let an automated loop rewrite only the code around it. That code layer is the harness, the runtime wrapper that feeds the model context, runs its tool calls, and decides when a run ends. By the time the loop finished, the system had essentially matched Sonnet 4.6 on the benchmark's headline metric, at roughly 7x lower cost per task. Zero weights changed. The gain existed because of where the model was failing. The judge only grades files saved in the right place under the exact requested filename, and the model kept doing the legal analysis correctly, then saving it under the wrong name, dropping it in a scratch folder, or never writing it at all. So the 0% was never measuring legal reasoning. It was measuring the harness. Hand-tuning that layer is slow and model-specific, so they automated it. A Claude proposer adds exactly one mechanism per iteration, and an outer loop keeps it only if it clearly beats the current best, so accepted mechanisms compound. What the loop discovered says a lot about where agents actually fail. → The biggest single gain was file handling, not intelligence. An automatic step that lands the deliverable exactly where the judge expects it beat every prompt change, with zero extra model tokens. → Code fixes transferred across models, prompt playbooks did not. The same harness lifted a smaller model from the same family by 14 points, but the tuned prompts hurt a different model family on tasks it could already finish. → The harness mattered more than anything else. Same model, same judge, same tasks, and five different harnesses scored anywhere between 3.5% and 80.1%. The gains do eventually flatten, and the remaining misses look like real capability gaps. At some point the wrapper runs out of tricks and the model has to carry the work. But the lesson holds. A benchmark score measures the model and its harness together, and until the harness is fixed, it's impossible to know which one failed. I highly recommend reading this: I also wrote a deep dive on agent harness engineering a while back, covering the orchestration loop, tools, memory, context management, and everything that turns a stateless LLM into a capable agent. The article is quoted below.
0:18

Don't train the model, evolve the harness. I read a brilliant blog post from Hugging Face where they took a frozen open model scoring 0% on a hard legal agent benchmark, left its weights alone, and let an automated loop rewrite only the code around it. That code layer is the harness, the runtime wrapper that feeds the model context, runs its tool calls, and decides when a run ends. By the time the loop finished, the system had essentially matched Sonnet 4.6 on the benchmark's headline metric, at roughly 7x lower cost per task. Zero weights changed. The gain existed because of where the model was failing. The judge only grades files saved in the right place under the exact requested filename, and the model kept doing the legal analysis correctly, then saving it under the wrong name, dropping it in a scratch folder, or never writing it at all. So the 0% was never measuring legal reasoning. It was measuring the harness. Hand-tuning that layer is slow and model-specific, so they automated it. A Claude proposer adds exactly one mechanism per iteration, and an outer loop keeps it only if it clearly beats the current best, so accepted mechanisms compound. What the loop discovered says a lot about where agents actually fail. → The biggest single gain was file handling, not intelligence. An automatic step that lands the deliverable exactly where the judge expects it beat every prompt change, with zero extra model tokens. → Code fixes transferred across models, prompt playbooks did not. The same harness lifted a smaller model from the same family by 14 points, but the tuned prompts hurt a different model family on tasks it could already finish. → The harness mattered more than anything else. Same model, same judge, same tasks, and five different harnesses scored anywhere between 3.5% and 80.1%. The gains do eventually flatten, and the remaining misses look like real capability gaps. At some point the wrapper runs out of tricks and the model has to carry the work. But the lesson holds. A benchmark score measures the model and its harness together, and until the harness is fixed, it's impossible to know which one failed. I highly recommend reading this: I also wrote a deep dive on agent harness engineering a while back, covering the orchestration loop, tools, memory, context management, and everything that turns a stateless LLM into a capable agent. The article is quoted below.

Akshay 🚀

245,379 views • 2 months ago

EVERYONE'S TRYING TO SOLVE AI TEAM MEMORY WITH SERVERS, VECTOR DATABASES, AND ORCHESTRATION PLATFORMS. THIS OPEN SOURCE TOOL DOES IT WITH ONE FOLDER IN YOUR REPO. Every dev on your team runs Claude Code. When one agent screws something up, the rest have no idea. They just repeat the mistake next week. It's called teamlore. When your agent gets corrected or breaks something, it writes a small lore file into a .lore/ folder. That file ships with your PR, gets reviewed like normal code, and after merge every teammate's agent automatically recalls it when they touch that part of the repo. No server. No datab No accounts. No SaaS bill. Just a folder in git. Which means code review catches bad lessons before they poison the team, git blame tells you when a rule was added and why, and the whole thing works offline. One command to install: npx teamlore init Companion command: npx teamlore scarmap. Turns your team's history of mistakes into a visual heat map of the codebase. Every red zone is a place your team has been burned before. Which means every red zone is a place your agents should slow down. Here's the wildest part. The teamlore repo's own .lore/ folder contains every mistake Claude made while building teamlore itself. Dogfooded end-to-end. You can literally open the folder and read the receipts. The author's public invitation: "Would love for someone to try and break it." Available on npm. Repo just launched. 100% open source. (link in the comments)
0:15

EVERYONE'S TRYING TO SOLVE AI TEAM MEMORY WITH SERVERS, VECTOR DATABASES, AND ORCHESTRATION PLATFORMS. THIS OPEN SOURCE TOOL DOES IT WITH ONE FOLDER IN YOUR REPO. Every dev on your team runs Claude Code. When one agent screws something up, the rest have no idea. They just repeat the mistake next week. It's called teamlore. When your agent gets corrected or breaks something, it writes a small lore file into a .lore/ folder. That file ships with your PR, gets reviewed like normal code, and after merge every teammate's agent automatically recalls it when they touch that part of the repo. No server. No datab No accounts. No SaaS bill. Just a folder in git. Which means code review catches bad lessons before they poison the team, git blame tells you when a rule was added and why, and the whole thing works offline. One command to install: npx teamlore init Companion command: npx teamlore scarmap. Turns your team's history of mistakes into a visual heat map of the codebase. Every red zone is a place your team has been burned before. Which means every red zone is a place your agents should slow down. Here's the wildest part. The teamlore repo's own .lore/ folder contains every mistake Claude made while building teamlore itself. Dogfooded end-to-end. You can literally open the folder and read the receipts. The author's public invitation: "Would love for someone to try and break it." Available on npm. Repo just launched. 100% open source. (link in the comments)

Harman

35,140 views • 1 month ago

AI has had exactly two scaling axes that worked so far, and the second one is starting to look finite too the first one was pretraining: with scaling parameters and data, we got world knowledge (i.e. ChatGPT had read enough to know things), but it started saturating a while ago the second one was RL, and people had been doing RL the whole time before that: RLHF is RL but it never scaled far because it was trying to control the exact output, which tokens come out, how the text reads, but you can only push that so far before you’re just polishing RLVR dropped that constraint: giving the model a task, then checking whether the final answer is right, and ignoring everything in between -- so the model does whatever it wants in the middle and only the endpoint gets graded, and that’s much closer to actual RL and it’s what bought us planning and reasoning (arguably, tool use sits around 2.5 on this list -- while useful, it's not a different kind of thing) so one axis gave knowledge, the other gave reasoning, and both of them are one model working alone the next axis is how many models you can get working on the same problem, which is a different kind of axis than the previous two we know that multi-agent RL has always been the harder problem: I spent years in that literature and the gap between single-agent and multi-agent is definitely not incremental -- it’s a whole different class of difficulty! which is also why the derivatives are steep at the start, nobody has picked the easy wins yet... and the thing that gates this multi-agent coordination is communication: models can only coordinate as well as they can exchange information, and right now they do that by writing sentences to each other imagine what could we possibly achieve if we properly open that third axis development by letting models to exchange information in their native "language" without loosing any computational data that they produce during inference
0:14

AI has had exactly two scaling axes that worked so far, and the second one is starting to look finite too the first one was pretraining: with scaling parameters and data, we got world knowledge (i.e. ChatGPT had read enough to know things), but it started saturating a while ago the second one was RL, and people had been doing RL the whole time before that: RLHF is RL but it never scaled far because it was trying to control the exact output, which tokens come out, how the text reads, but you can only push that so far before you’re just polishing RLVR dropped that constraint: giving the model a task, then checking whether the final answer is right, and ignoring everything in between -- so the model does whatever it wants in the middle and only the endpoint gets graded, and that’s much closer to actual RL and it’s what bought us planning and reasoning (arguably, tool use sits around 2.5 on this list -- while useful, it's not a different kind of thing) so one axis gave knowledge, the other gave reasoning, and both of them are one model working alone the next axis is how many models you can get working on the same problem, which is a different kind of axis than the previous two we know that multi-agent RL has always been the harder problem: I spent years in that literature and the gap between single-agent and multi-agent is definitely not incremental -- it’s a whole different class of difficulty! which is also why the derivatives are steep at the start, nobody has picked the easy wins yet... and the thing that gates this multi-agent coordination is communication: models can only coordinate as well as they can exchange information, and right now they do that by writing sentences to each other imagine what could we possibly achieve if we properly open that third axis development by letting models to exchange information in their native "language" without loosing any computational data that they produce during inference

Sasha Malysheva

15,010 views • 1 month ago