正在加载视频...

视频加载失败

返回首页

holy sh*t. Jev's founder Diogo Almeida dropped a Google Doc on coding agents one of these PDFs has the map everyone needs: where Jev sits in an agent loop ↓ agents do the work, Jev makes the calls, the LLM only writes: 1 → task in: one Noul before...

ArchiveExplorer's profile picture

Archive

12,432 subscribers

31,914 次观看 • 2 天前 •via X (Twitter)

科学技术
LIVE

Anya Rossi• Live Now

Private livecam show

0 条评论

暂无评论

原始帖子的评论将显示在这里

相关视频

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 state into a bounded action such as click, type, or stop. Code executes only valid operation-target pairs. There are already several open-source Jev web agents. 2. Context compaction > Decide which events from a long agent trace should remain. The selected text stays verbatim instead of being replaced with a generated summary. 3. Skill and context loading > Compare the current user turn against the available skills. Load only the instructions needed for that turn instead of filling the context window with every skill. 4. Typed tool-call compilation > Map a natural-language request to a function and fill its typed arguments. Each argument is evaluated separately before code allows execution. 5. Citation verification > Check whether a quoted passage exists and whether the surrounding evidence supports the claim. The output can be supported, unsupported, or contradicted. 6. Extraction verification > Run a cheap extractor first, then use Jev to verify questionable fields. Clean records stay on the fast path while uncertain ones reach a reasoning model. 7. Agent trace evaluation > Turn raw trajectories into queryable labels such as progress and repetition. This avoids asking another LLM to write a full review of every run. 8. Semantic regression tests > Replay a trace suite against a new agent build. Semantic checks can then pass or block prompt, model, tool, and policy changes in CI. 9. Jevgrep code search > Search a codebase by what the code does rather than its exact words. Jev scores candidate snippets and returns the most relevant code first. 10. Entity alignment > Compare two candidate records and decide whether to merge, review, or keep them separate. Candidate generation remains deterministic while Jev handles semantic identity. 11. Retrieval reranking > Let embeddings retrieve a broad candidate set, then use Jev to reorder passages by relevance. The generation model receives the most useful evidence first. 12. Memory promotion gate > Capture a completed agent trace, then judge whether its corrections contain a reusable lesson. Trace-backed lessons can be promoted while task-specific noise is discarded. If you want to see the final pattern in practice, it is already implemented in the Beacon open-source project. Beacon captures full sessions across Claude Code, Codex, Cursor, OpenCode, and 20+ agent harnesses, and then Jev identifies which workflows and corrections are worth learning from, so that a lesson discovered by one agent can become available to the others. GitHub repo: (don’t forget to star it ⭐) If you want to dive deeper, I also wrote about a similar mechanism in a hands-on guide. It covers building a Jev-style decision path with open models, entirely locally. Read it below.
0:16

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 state into a bounded action such as click, type, or stop. Code executes only valid operation-target pairs. There are already several open-source Jev web agents. 2. Context compaction > Decide which events from a long agent trace should remain. The selected text stays verbatim instead of being replaced with a generated summary. 3. Skill and context loading > Compare the current user turn against the available skills. Load only the instructions needed for that turn instead of filling the context window with every skill. 4. Typed tool-call compilation > Map a natural-language request to a function and fill its typed arguments. Each argument is evaluated separately before code allows execution. 5. Citation verification > Check whether a quoted passage exists and whether the surrounding evidence supports the claim. The output can be supported, unsupported, or contradicted. 6. Extraction verification > Run a cheap extractor first, then use Jev to verify questionable fields. Clean records stay on the fast path while uncertain ones reach a reasoning model. 7. Agent trace evaluation > Turn raw trajectories into queryable labels such as progress and repetition. This avoids asking another LLM to write a full review of every run. 8. Semantic regression tests > Replay a trace suite against a new agent build. Semantic checks can then pass or block prompt, model, tool, and policy changes in CI. 9. Jevgrep code search > Search a codebase by what the code does rather than its exact words. Jev scores candidate snippets and returns the most relevant code first. 10. Entity alignment > Compare two candidate records and decide whether to merge, review, or keep them separate. Candidate generation remains deterministic while Jev handles semantic identity. 11. Retrieval reranking > Let embeddings retrieve a broad candidate set, then use Jev to reorder passages by relevance. The generation model receives the most useful evidence first. 12. Memory promotion gate > Capture a completed agent trace, then judge whether its corrections contain a reusable lesson. Trace-backed lessons can be promoted while task-specific noise is discarded. If you want to see the final pattern in practice, it is already implemented in the Beacon open-source project. Beacon captures full sessions across Claude Code, Codex, Cursor, OpenCode, and 20+ agent harnesses, and then Jev identifies which workflows and corrections are worth learning from, so that a lesson discovered by one agent can become available to the others. GitHub repo: (don’t forget to star it ⭐) If you want to dive deeper, I also wrote about a similar mechanism in a hands-on guide. It covers building a Jev-style decision path with open models, entirely locally. Read it below.

Avi Chawla

122,419 次观看 • 3 天前

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

42,282 次观看 • 8 天前

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 次观看 • 7 天前

JEV ENGINEERING JUST CUT A CLAUDE LOOP FROM $765/MONTH TO $3.02 the expensive part isn’t always writing code. a busy overnight loop can burn ~600 decisions just asking what to do next, whether a command is safe, or if the task is finished. trigger → Jev → allow / stop / wake → Claude only builds when needed at roughly 4,000 tokens per decision, those checks can cost ~$25.50 a night on Fable 5.1. Jev handles the same decision layer at $0.042 per 1M input tokens with output free. over 30 nights that moves the decision bill from ~$765 to $3.02. batch multiple questions into one call and it falls again to about $1.08/month. that’s the part i care about: Claude keeps the expensive work that actually needs intelligence, while Jev handles the hundreds of tiny judgment calls around it.
0:15

JEV ENGINEERING JUST CUT A CLAUDE LOOP FROM $765/MONTH TO $3.02 the expensive part isn’t always writing code. a busy overnight loop can burn ~600 decisions just asking what to do next, whether a command is safe, or if the task is finished. trigger → Jev → allow / stop / wake → Claude only builds when needed at roughly 4,000 tokens per decision, those checks can cost ~$25.50 a night on Fable 5.1. Jev handles the same decision layer at $0.042 per 1M input tokens with output free. over 30 nights that moves the decision bill from ~$765 to $3.02. batch multiple questions into one call and it falls again to about $1.08/month. that’s the part i care about: Claude keeps the expensive work that actually needs intelligence, while Jev handles the hundreds of tiny judgment calls around it.

Gipp 🦅

25,010 次观看 • 2 天前

We gave Jev 2,029 real phone calls. No transcripts or audio; it never heard a word. Our AI receptionist's calls were reduced to pure structure, meaning turns, tool calls, workflow stages and timing. During the calls, Jev made 38,012 turn-level forecasts at 118 ms median latency, reviewed every call with five typed questions and produced 10,145 answers in 26 seconds with 256 requests in flight. The experiment was zero-shot, with no fine-tuning or examples from our data. We compared Jev's forecasts with what actually happened in the EHR. By the halfway point, Jev could meaningfully separate calls that would book from those that wouldn't (AUC 0.78), and near the end it ranked them correctly 94% of the time. Even though Jev over-focused on visible errors our agent usually overcomes, it's still pretty incredible that it analyzed thousands of real calls in seconds for only $3.
0:11

We gave Jev 2,029 real phone calls. No transcripts or audio; it never heard a word. Our AI receptionist's calls were reduced to pure structure, meaning turns, tool calls, workflow stages and timing. During the calls, Jev made 38,012 turn-level forecasts at 118 ms median latency, reviewed every call with five typed questions and produced 10,145 answers in 26 seconds with 256 requests in flight. The experiment was zero-shot, with no fine-tuning or examples from our data. We compared Jev's forecasts with what actually happened in the EHR. By the halfway point, Jev could meaningfully separate calls that would book from those that wouldn't (AUC 0.78), and near the end it ranked them correctly 94% of the time. Even though Jev over-focused on visible errors our agent usually overcomes, it's still pretty incredible that it analyzed thousands of real calls in seconds for only $3.

Muratcan Koylan

199,630 次观看 • 21 小时前

Alright, now that we know *what* an agent is, how does it actually work? When you ask for help on a task, the agent plans a series of steps and executes them directly in the application on your behalf, using the tools it has access to. Say you are booking a local service or trying to organize your inbox (which typically takes multiple steps): the AI model first plans how to achieve the task using its existing knowledge and then interacts with your inbox to execute the task. The agent will continue until it is confident the task has been successfully completed.
0:15

Alright, now that we know *what* an agent is, how does it actually work? When you ask for help on a task, the agent plans a series of steps and executes them directly in the application on your behalf, using the tools it has access to. Say you are booking a local service or trying to organize your inbox (which typically takes multiple steps): the AI model first plans how to achieve the task using its existing knowledge and then interacts with your inbox to execute the task. The agent will continue until it is confident the task has been successfully completed.

Google AI

22,487 次观看 • 10 个月前

You've probably scrolled past a dozen posts about Jev this week without anyone telling you what it actually is. It's the first model from TypeSafe, a lab started by one of the researchers behind ChatGPT. It's a decision engine: you give it options, it picks one and tells you how sure it is. It cannot write a single word, and that is the interesting part. Every other AI you use writes. That is the whole interface. So when software needs a plain yes or no, we make a model write a paragraph and then dig the answer back out of it. Fine in a chat window where a human reads it. Bad inside software, where code has to act on it. The bet is that the valuable half was never the writing. It was the deciding. That problem showed up in WordPress years ago, and it is the reason WPVibe works the way it does. The AI does the work. Anything permanent stops and waits, because a delete that skips the trash is not something software should decide on its own.
0:14

You've probably scrolled past a dozen posts about Jev this week without anyone telling you what it actually is. It's the first model from TypeSafe, a lab started by one of the researchers behind ChatGPT. It's a decision engine: you give it options, it picks one and tells you how sure it is. It cannot write a single word, and that is the interesting part. Every other AI you use writes. That is the whole interface. So when software needs a plain yes or no, we make a model write a paragraph and then dig the answer back out of it. Fine in a chat window where a human reads it. Bad inside software, where code has to act on it. The bet is that the valuable half was never the writing. It was the deciding. That problem showed up in WordPress years ago, and it is the reason WPVibe works the way it does. The AI does the work. Anything permanent stops and waits, because a delete that skips the trash is not something software should decide on its own.

John Turner

21,029 次观看 • 12 天前

Jev + GrokBot is the best AI agent system I’ve built in my life It just made my setup CHEAPER and FASTER than what 95% of people are running... setup takes literally 7 minutes: prompt → GrokBot → Jev decision → GrokBot execution → result step 1 → open TypeSafe AI , create API key (keep it off chat paste) step 2 → tell Grok Bot: store TYPESAFE_API_KEY in the secure field step 3 → prompt Grok Bot: install typesafe-sdk on Agent Computer + smoke system_one (Choice) step 4 → tell Grok Bot: build the usage lab (router, dry-run, config, logs) - or clone Github below step 5 → add skill jev-usage-router: before browser / research / retry / extra bot → call the router, honor action step 6 → stay shadow first, read logs, then active when you trust it - kill switch: bypass jev or enabled: false step 7 → flip active: GrokBot obeys route - Jev decides - GrokBot executes - humans control irreversible actions the result: Jev + GrokBot the best and fastest agent running directly on your computer rn, I’ve already tested it on routine tasks - and the results are genuinely incredible You can come up with endless ways to use Jev + GrokBot - but the most important thing is to install it as soon as possible Copy this 2028 setup, explore my repo below - then read the full Jev deep dive ↓
0:15

Jev + GrokBot is the best AI agent system I’ve built in my life It just made my setup CHEAPER and FASTER than what 95% of people are running... setup takes literally 7 minutes: prompt → GrokBot → Jev decision → GrokBot execution → result step 1 → open TypeSafe AI , create API key (keep it off chat paste) step 2 → tell Grok Bot: store TYPESAFE_API_KEY in the secure field step 3 → prompt Grok Bot: install typesafe-sdk on Agent Computer + smoke system_one (Choice) step 4 → tell Grok Bot: build the usage lab (router, dry-run, config, logs) - or clone Github below step 5 → add skill jev-usage-router: before browser / research / retry / extra bot → call the router, honor action step 6 → stay shadow first, read logs, then active when you trust it - kill switch: bypass jev or enabled: false step 7 → flip active: GrokBot obeys route - Jev decides - GrokBot executes - humans control irreversible actions the result: Jev + GrokBot the best and fastest agent running directly on your computer rn, I’ve already tested it on routine tasks - and the results are genuinely incredible You can come up with endless ways to use Jev + GrokBot - but the most important thing is to install it as soon as possible Copy this 2028 setup, explore my repo below - then read the full Jev deep dive ↓

codila

381,094 次观看 • 10 天前

Jev + Kimi K3 for fraud detection! TLDR: Jev classified 100 emails in 1.42 seconds, then I routed the uncertain cases to Kimi K3. The full pipeline got 96/100 correct for only ~$0.07. Video is not sped up, check out the live run! Here was my process: I gave Jev 100 emails to classify (a mix of 50 legit & 50 fraudelent emails). It classified all of them in 1.42 seconds. An underrated feature about Jev is it will give you the confidence score for a classification, so I routed any prediction under 95% confidence to Kimi K3 to be fully sure. 31 emails fell below that threshold. After routing those to Kimi K3, the combined pipeline reached 96% accuracy. The full run took 16 seconds & ~$0.07 in inference costs: - $0.068 from Kimi K3 on Together AI - $0.003 (1/3 of a cent) from Jev on TypeSafe AI. I think this is a really interesting pattern: use a fast specialized model like Jev for the narrow task, then route the uncertain cases to a larger LLM. I feel like this kind of approach could be a game changer for use cases like fraud or anything realtime. You can use the speed & low cost of Jev while having a larger LLM as a fallback to ensure high accuracy.
0:12

Jev + Kimi K3 for fraud detection! TLDR: Jev classified 100 emails in 1.42 seconds, then I routed the uncertain cases to Kimi K3. The full pipeline got 96/100 correct for only ~$0.07. Video is not sped up, check out the live run! Here was my process: I gave Jev 100 emails to classify (a mix of 50 legit & 50 fraudelent emails). It classified all of them in 1.42 seconds. An underrated feature about Jev is it will give you the confidence score for a classification, so I routed any prediction under 95% confidence to Kimi K3 to be fully sure. 31 emails fell below that threshold. After routing those to Kimi K3, the combined pipeline reached 96% accuracy. The full run took 16 seconds & ~$0.07 in inference costs: - $0.068 from Kimi K3 on Together AI - $0.003 (1/3 of a cent) from Jev on TypeSafe AI. I think this is a really interesting pattern: use a fast specialized model like Jev for the narrow task, then route the uncertain cases to a larger LLM. I feel like this kind of approach could be a game changer for use cases like fraud or anything realtime. You can use the speed & low cost of Jev while having a larger LLM as a fallback to ensure high accuracy.

Hassan

60,099 次观看 • 12 天前

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 次观看 • 9 天前

I used Jev to classify 1,018 AI research papers. The result: $0.08 total cost and 256ms median end-to-end latency per paper. The pipeline was: 1. Summarize each paper with DeepSeek V4 Flash 2. Send the title + summary + 24 possible topics to Jev 3. Use Jev to classify each paper 4. Visualize everything on The summaries cost $3.99 on Together AI. The classifications cost $0.08 on TypeSafe AI. So for just over $4 of inference, I ended up with a pretty useful way to explore the top AI research papers from the past year. I think this is where things are heading: different models for different parts of the workflow, instead of using one model for everything. I’m running evals on the Jev classifications before replacing the current ones, but the site is already live:
0:10

I used Jev to classify 1,018 AI research papers. The result: $0.08 total cost and 256ms median end-to-end latency per paper. The pipeline was: 1. Summarize each paper with DeepSeek V4 Flash 2. Send the title + summary + 24 possible topics to Jev 3. Use Jev to classify each paper 4. Visualize everything on The summaries cost $3.99 on Together AI. The classifications cost $0.08 on TypeSafe AI. So for just over $4 of inference, I ended up with a pretty useful way to explore the top AI research papers from the past year. I think this is where things are heading: different models for different parts of the workflow, instead of using one model for everything. I’m running evals on the Jev classifications before replacing the current ones, but the site is already live:

Hassan

337,656 次观看 • 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.
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 次观看 • 6 天前

here's how to make money with jev on autopilot it's a super fast decision model, so it picks an answer in a fifth of a second and tells you how sure it is - put instant pricing on a business that has none - sell the same thing to bigger businesses for more - sell a file that decides what an agent may do - charge monthly to keep all of it running - costs a fraction of a cent per decision - runs on hermes or grok bot, on a schedule just wrote a whole guide on how you can set this up:
0:11

here's how to make money with jev on autopilot it's a super fast decision model, so it picks an answer in a fifth of a second and tells you how sure it is - put instant pricing on a business that has none - sell the same thing to bigger businesses for more - sell a file that decides what an agent may do - charge monthly to keep all of it running - costs a fraction of a cent per decision - runs on hermes or grok bot, on a schedule just wrote a whole guide on how you can set this up:

Chris

90,674 次观看 • 9 天前

If you're building an agentic workspace, your nav has a job normal navs don't The job: - Agents run async, out of sight, so the UI has to prove work is happening - No modals or stuff like that, just ambient signal in a bar people already watch Show the work: - The Agents icon wears a live ring the moment an agent picks up a task - It fires in real bursts, then rests, so it reads like a teammate instead like a spinner stuck on What's it doing: - Hover mid task and the state goes live: Writing code… Running tests… Reading docs… - Status sits on the icon, not buried three clicks deep Why it matters: - Trust in agents comes from knowing they're alive and working - Bake that into the nav and every screen you ship gets it for free
0:19

If you're building an agentic workspace, your nav has a job normal navs don't The job: - Agents run async, out of sight, so the UI has to prove work is happening - No modals or stuff like that, just ambient signal in a bar people already watch Show the work: - The Agents icon wears a live ring the moment an agent picks up a task - It fires in real bursts, then rests, so it reads like a teammate instead like a spinner stuck on What's it doing: - Hover mid task and the state goes live: Writing code… Running tests… Reading docs… - Status sits on the icon, not buried three clicks deep Why it matters: - Trust in agents comes from knowing they're alive and working - Bake that into the nav and every screen you ship gets it for free

mateja

23,922 次观看 • 2 个月前

Let me explain the agent loop, simple It's the core of every agentic system, and the part most people overcomplicate It's just this: 1. Send messages to the model 2. Model responds, maybe calls a tool 3. You run the tool 4. Append the result back to messages 5. Repeat until stop_reason is end_turn Step 4 is the whole thing, the write-back is what makes it an agent The model has to see what actually happened before it decides the next move That's the entire loop... understand this cold before you reach for a framework
0:14

Let me explain the agent loop, simple It's the core of every agentic system, and the part most people overcomplicate It's just this: 1. Send messages to the model 2. Model responds, maybe calls a tool 3. You run the tool 4. Append the result back to messages 5. Repeat until stop_reason is end_turn Step 4 is the whole thing, the write-back is what makes it an agent The model has to see what actually happened before it decides the next move That's the entire loop... understand this cold before you reach for a framework

Daniel San

12,514 次观看 • 3 个月前

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,965 次观看 • 1 个月前

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 次观看 • 11 天前

THIS IS HOW FABLE 5 MOVES WHEN YOUR VAULT IS BUILT RIGHT direct path. zero wandering. hits the target on the first try. without structure it's the opposite. 7 files opened. 2 minutes wasted. brief from 3 months ago still missing. one index file per major folder. gives the agent a direct line to what it needs. same task dropped from 2 minutes to 10 seconds. same model. nothing else changed. build the path or watch it search in the dark. full breakdown in the article below ↓
0:19

THIS IS HOW FABLE 5 MOVES WHEN YOUR VAULT IS BUILT RIGHT direct path. zero wandering. hits the target on the first try. without structure it's the opposite. 7 files opened. 2 minutes wasted. brief from 3 months ago still missing. one index file per major folder. gives the agent a direct line to what it needs. same task dropped from 2 minutes to 10 seconds. same model. nothing else changed. build the path or watch it search in the dark. full breakdown in the article below ↓

Avid

909,715 次观看 • 2 个月前

SOMEONE MAPPED CHAOS INTO A NAVIGABLE SPACE AND YOUR HERMES AGENT NEEDS THE SAME THING thousands of chaotic data points, each given a position, navigation becomes instant because the structure does the work your vault is the same chaos, hermes lands in it and opens files at random because nothing tells it where to start one index file per major folder with a clear starting point changes everything 2 minutes per task drops to 10 seconds, same agent, same model full breakdown in the article below ↓
0:13

SOMEONE MAPPED CHAOS INTO A NAVIGABLE SPACE AND YOUR HERMES AGENT NEEDS THE SAME THING thousands of chaotic data points, each given a position, navigation becomes instant because the structure does the work your vault is the same chaos, hermes lands in it and opens files at random because nothing tells it where to start one index file per major folder with a clear starting point changes everything 2 minutes per task drops to 10 seconds, same agent, same model full breakdown in the article below ↓

leopardracer

23,629 次观看 • 3 个月前