Explore real Jev AI features, experiments and tutorials from X and YouTube. Each example focuses on one decision you can apply in your own project.
Browse demos and production examples by the problem they solve. Each X post and YouTube video includes our explanation of the specific decision Jev handles.
Showing 69 of 69 curated examples
Moritz Kremb builds a voice-controlled browser in a longer tutorial. Speech is transcribed first; Jev then judges the intended action and target among the current page elements.
Jev is one stage in the loop. Speech recognition, browser state, safety checks and the actual click are handled outside the model.
Riley Brown walks through Jev’s three output shapes and shows several small applications, including routing a request to a model and triaging email.
Start with the output format: choose one option, assign a numeric score or answer a yes-or-no question. The application remains responsible for acting on the result.
TypeSafe DevRel Allie Laabs joins ThursdAI to explain System One models and the Choice, Score and Noul primitives. The segment includes a tweet classifier and a live game demo.
This is useful background from the team, with demonstrations and open questions. Performance and price figures discussed in the interview are the speakers’ claims.
Frederik Hermann describes 23andMe using Jev to judge new drafts against qualities learned from previously published articles, including tone, clarity and scientific accuracy.
The team keeps health-related content under human review and uses the scores to accelerate clear cases. This is a prioritization layer, not an automated publishing decision.
POK-Agent separates planning from execution: a larger model plans a task, Jev chooses actions from the current screen state, and successful repetitions become reusable routines.
The open-source project reports 28% fewer planner calls on replayed tasks. The host application still controls actions, permissions and recovery when the decision is uncertain.
The Goose team publishes a walkthrough for connecting Jev through an Agent Skill and using typed decisions inside a Goose workflow.
The tutorial demonstrates the integration boundary rather than one fixed application. Developers still define the state, answer options and action taken after the result.
OpenMuse uses Jev to decide when a researched answer benefits from clickable comparison cards and how those cards should be ordered.
The cards come from pages the research tool already read. Jev selects presentation and ranking; it does not invent the source material.
Mathias demonstrates Jev evaluating an application during a QA flow, turning open-ended inspection into a set of bounded checks.
The short demo shows the interaction pattern but does not publish a benchmark or full test suite. Deterministic assertions should remain the first choice when an exact check is available.
Takuma Oka proposes using Jev for the first pass over crawl or Search Console data, assigning URLs to keep, rewrite, consolidate or review queues.
This is a practical workflow proposal, not a reported production benchmark. Search intent and site-wide strategy stay with the editor; Jev narrows the review set.
Qlty releases SlopOne as a research preview in its CLI, combining static analysis with Jev judgments about whether code will be difficult for an experienced developer to maintain.
Qlty reports better prediction in its own testing, but the preview is not a substitute for tests or code review. Its useful role is prioritizing files and generating focused refactoring prompts.
TraceRoot adds Jev as a detector judge that estimates whether a trace has a problem and assigns probabilities to possible problem types.
The feature makes probabilistic triage inspectable, but teams still need their own labels, thresholds and human review for consequential incidents.
OpenRouter Armor uses Jev to evaluate an agent tool call against policy before the call can interact with an external system.
OpenRouter reports stronger results than its Claude Code auto-classifier comparison at lower cost. That is a vendor result; enforcement still belongs in the runtime, with explicit deny rules and audit logs.
Caine demonstrates an audio-action model that listens to a command and uses Jev to choose from the actions available on the current mobile screen.
The creator reports speed and cost improvements over Gemini Live, which we have not independently reproduced. Execution should remain bounded to reversible, permission-aware actions.
PR Lens uses Jev image input to interpret a screenshot attached to an agent-authored pull request and place the visible change within a canvas of system components and data flow.
The visual map helps reviewers form a mental model; it is not proof that the code is correct. Diff review, tests and security checks remain necessary.
Oskar pairs Jev vision with e2e tests to check canvas content, charts, strikethroughs and hand-drawn text that are difficult to inspect through the accessibility tree alone.
Visual judgment complements deterministic selectors; it should not replace exact DOM or API assertions where those are available. Store screenshots and thresholds so failures remain reviewable.
Papers with Code first finds candidate phrases with rules, then uses Jev to judge whether each phrase refers to a method or benchmark that should link to its reference page.
The production pipeline combines deterministic candidate generation with semantic judgment. The team reports processing 121,000 papers for about $5; that figure is specific to its implementation.
Avi Chawla demonstrates Beacon capturing agent trajectories and using Jev to judge which corrections and engineering lessons are reusable across coding-agent harnesses.
A decision layer can reduce noisy memory, but retained lessons still need provenance, expiry and a way to correct bad guidance. The post describes an open-source integration rather than an independent benchmark.
Cris Lenta shows a San Francisco simulation populated with more than 800 Jev-powered characters making real-time decisions.
The video demonstrates scale and visual variety, not a measured gameplay or simulation benchmark. Rules, world state and valid actions remain part of the simulation engine.
System One Computer Use is an open-source prototype that repeats a screenshot, decision and click-or-type loop while recording screenshots, decisions and cost for each step.
The project explicitly stops when uncertain instead of guessing. It remains a prototype: permissions, sensitive actions and state verification need stronger controls before unattended use.
Treg publishes an open-source people-search tool powered by Jev, exposing ranked lead results that can be called from another agent.
Pricing and benchmark leadership are creator claims. Responsible use also requires lawful data sources, privacy controls and review before outreach.
Booksmith turns Calibre books into narrated audiobooks and uses Jev to choose the intended pronunciation of ambiguous words such as “lead” and “read” from context.
Jev selects pronunciation while Kokoro generates speech and the application creates chapters and Plex assets. The creator reports the processing time for one novel; it is not a general benchmark.
HiRoute uses Jev to judge whether incoming activity starts a new turn, while recognized continuations reuse the previous tool-routing decision.
Reusing a valid decision can avoid needless routing calls. The open-source project still needs explicit rules for stale state, interrupted tasks and ambiguous continuations.
DAILYPAPER-SKILLS collects papers from Hugging Face and arXiv, uses Jev to score topic relevance, then asks an agent to write reviews and Obsidian notes for the selected papers.
The split keeps high-volume filtering away from the writing model. Search recall, changing interests and source provenance still need to be visible to the reader.
Google ADK 2.13 adds native Jev support for routing, giving an agent workflow a typed decision step without asking a generative model to write the route.
Native integration reduces glue code, but developers still own the branch definitions, confidence policy and fallback behavior.
Sangyop Lee reports using Jev for qualitative coding in a research project on classical Chinese Buddhist biographies.
The researcher reports results comparable to frontier language models at roughly one tenth of the cost. That is a project-specific observation; scholarly coding still requires a documented codebook and reliability checks.
Sana demonstrates Workday actions completed through a dynamic interface and states that the experience is powered by Jev.
The public post shows the product experience but not its full architecture or benchmark. Jev supplies a decision inside a wider Sana and Workday workflow.
Sumanth’s open-source research agent uses Nemotron and Tavily to gather material, then asks Jev whether the result sufficiently supports and covers the user’s question.
Jev acts as a review gate rather than the researcher or writer. A useful implementation should expose missing evidence and loop limits instead of repeating searches indefinitely.
Satoshi Nagayasu builds a prototype that combines Jev decisions with an abstract syntax tree to turn natural-language requests into constrained SQL.
The AST provides deterministic structure while Jev resolves bounded semantic choices. Database permissions, query validation and resource limits remain mandatory.
Allie Laabs describes a custom voice agent that sends streaming speech-to-text updates to Jev, warming likely intent handlers and sometimes taking low-risk actions before the utterance ends.
Early action should be limited by risk and reversibility. Ambiguous speech, corrections and sensitive operations need confirmation even when the predicted intent is confident.
Bruin introduces inference assets that can enrich warehouse data during a pipeline, including using Jev to categorize support issues stored in Snowflake.
Treating inference as a pipeline asset improves scheduling and observability. Teams still need batching, retries, versioned prompts and a review path for uncertain rows.
Jev Skill Typeahead evaluates a prompt while it is being typed and shows the estimated probability that each installed Claude Code skill will be selected.
The preview helps developers inspect and tune skill routing before execution, without consuming Claude tokens. It predicts the route; Claude Code still performs the task.
Joe Jiang describes adding Jev to an automated testing system so it can choose which on-screen control to press as different games move through different interface states on an iPhone.
The post reports a strong practical result but does not publish a test corpus. Device automation, assertions and recovery remain outside the decision model.
Marco Franzon combines stock YOLO person detection with a local 27B vision decision model identified as Jev, asking it to judge helmets, vests and risk for each cropped person.
The creator reports zero-shot helmet results on one dataset that exceeded his fine-tuned YOLO comparison. Safety deployment requires independent testing across sites, lighting, equipment and demographic variation.
BookSaver reports moving its browser-use decision step from a conventional language model to Jev after a multi-week test.
The creator reports a threefold speed improvement and roughly one-hundredfold lower cost in this application. Those figures are self-reported and workload-specific; browser safeguards remain essential.
Sanity describes an internal harness that lets employees create agents with their own knowledge, instructions and tools, using Jev as the router.
Sanity reports that the router has worked well in its internal use. Its engineering write-up is an implementation example, not a universal routing benchmark.
Composio Firewall evaluates actions and incoming information with Jev and Composio-tuned small models before an agent crosses its runtime boundary.
A learned firewall complements sandboxing, authentication and deterministic policy; it should not replace them. Decisions need logs, explicit fail-closed behavior and human escalation for sensitive actions.
Joseph Zhou connects Google Research’s Harness² to Jev 1.14. The experimental loop rewrites prompts, builds image-processing tools and retains successful tactics while running vision tasks.
The video reports repeated benchmark gains without weight updates, but the repository was not yet available when checked. Treat it as an experimental demonstration until code and evaluation details are published.
Avid’s Keel walkthrough places Jev between coding-agent proposals and host execution. Typed questions choose a route or tool focus, while the harness records decisions for later inspection and replay.
Jev supplies a judgment; the host still enforces permissions and executes tools. Treat the walkthrough as an implementation pattern, and keep a larger-model or human fallback for uncertain decisions.
Hassan publishes a reproducible recipe for fine-tuning Qwen3.5-4B on bounded classification tasks, deploying it on Together AI and querying it with a state, a question and a fixed set of answer options.
Tev1 is an independent, Jev-inspired model—not TypeSafe’s Jev. Its published results reuse development benchmarks, and token log probabilities are not calibrated confidence; use a fresh holdout before relying on a fine-tune.
Google Gemma highlights a one-command Cloud Run deployment for DiffusionGemma-Jev, an independent implementation of a Jev-compatible endpoint. The deployment example evaluates incident urgency, team ownership and severity together.
This is not TypeSafe’s hosted Jev model. Google Gemma reports roughly 35–60 ms for a single step and 100–123 requests per second at batch 32; hardware, cold starts and calibration still need workload-specific testing.
Gregor shows an open-source browser agent using DOM state and a changing set of available actions. Jev selects each step, with a small language-model fallback when text input is needed.
The creator reports a flight-search example at about 7 seconds and $0.0039. Treat those figures as a demo claim, not a benchmark; action execution and safeguards stay in the application.
Tamara demonstrates scoring individual tool calls and dropping irrelevant ones instead of rewriting the retained context as a generated summary.
Per-call filtering preserves the selected original text, but dependencies between steps and audit requirements still need deterministic checks.
Aaron Levie demonstrates an agent reading an incident report from Box, judging whether customers are affected and how severe the incident is, then moving the file to an escalation, monitoring or review folder.
The useful boundary is between a short classification and the workflow that acts on it. Folder moves and metadata updates stay in application code.
In a Spanish-language demo, Alan Daitch pairs Playwright with Jev to review used-item listings. Jev answers checks about the item and its fit; the surrounding workflow discards, bids or asks the seller for missing details.
The post’s follow-up describes five yes-or-no checks on page text. Browser navigation, offers and seller messages are separate actions that need review rules and safeguards.
Rinte’s Japanese-language demo selects a presentation slide that matches the current spoken topic, without the presenter touching a pointer or keyboard.
This is a selection task over existing slides. Speech capture and the slide display are parts of the application around Jev; the demo does not show Jev generating slides.
Kaneko’s Japanese-language prototype updates three meeting signals after each utterance: exploration or convergence, resolved or pending, and disagreement or agreement.
Repeated, bounded judgments can make a live discussion easier to follow. The prototype is a visualization, not proof that the labels accurately represent every participant’s intent.
In a Chinese-language demo, Sac combines Codex and Jev to add a Mac calendar event, showing the same task with and without the Jev-assisted workflow.
The side-by-side video makes responsiveness visible, but it is one creator’s comparison rather than a controlled speed benchmark. The app still executes and verifies each action.
A Chinese-language demo runs Jev over a stream of news items for 15 brands, assigning structured intent labels and identifying stories that may be relevant to each brand.
The creator reports a fast batch run. Replies point out visible classification errors, so editorial review and a measured accuracy check matter before using the output for PR decisions.
Nader shows intent-based Gmail search and notes that a large inbox can use semantic retrieval first, then let Jev judge the smaller candidate set.
Retrieval and judgment are separate stages. Mail permissions, candidate recall and a way to inspect missed results remain important.
Duncan shows a router that asks Jev which model fits an incoming request, then sends the request to that model. Jev makes the routing decision; another model handles the open-ended response.
A bounded choice can sit ahead of a generative model. The router still needs fallback rules and evaluation against real requests.
Bannerbear describes a live feature that maps source fields to template fields even when their names differ, such as avatar to photo or full_name to name.
This is a compact semantic matching task with a fixed set of candidate fields. A product should still let users inspect and correct a proposed mapping.
Nader Dabit shares a predictive spreadsheet demo: entering a heading such as “Urgency” makes the sheet judge the meaning of each row, rather than only recalculate numeric formulas.
A score can augment a spreadsheet when the useful signal is semantic. The demo is a prototype, so its ratings still need testing before operational use.
Cream O’s open-source ZenFeed extension batches post snippets, asks Jev whether each post matches the user’s filter criteria, then softly blurs or collapses matches without shifting the feed layout.
The project reports sub-200 ms decisions, which we have not independently benchmarked. Its safer design choices include a separate allow-list check, a confidence threshold, caching and leaving posts visible when a request fails.
A creator describes feeding Wireshark packet data to a Jev-powered classifier. The prototype surfaced traffic that they investigated as possible backdoor activity on a family network.
This is a creator-reported anecdote, not a validated security finding. Authorized capture scope, deterministic rules and expert review are essential before taking action.
Marcel Pociot shows a macOS app watching the Downloads folder. It judges whether a new file is an invoice, then files and renames matching documents according to a configured rule.
The creator says low-confidence files stay in place for manual review. That threshold and duplicate detection matter more than making every file move automatic.
Hassan shows a pipeline that first classifies a batch of emails with Jev, then sends uncertain cases to another model. The example separates a fast first pass from closer review.
The valuable design choice is the uncertainty threshold. The creator’s reported accuracy applies to that demo batch, not to every inbox or fraud pattern.
Riley Brown demonstrates Jev classifying 500 emails in seconds, using bounded categories instead of generating a response for each message.
The creator reports a total cost of about $0.035 for the demo. Production use still needs a defined label set, confidence handling and human review for consequential messages.
Rahul Goel reports sending 392 recorded sales calls and eight MEDDPICC fields to Jev in one pass, producing 3,136 structured judgments with probabilities and supporting excerpts.
The creator reports 2.94 million input tokens and a total cost of $0.1235. Treat this as one dataset’s run, not a general SLA; consent, access controls, transcription quality and calibration still matter.
Paolo Rosson feeds a code diff into Jev and receives a set of judgments about possible secrets, SQL injection, authentication changes, missing tests and other review signals.
These are review prompts, not proof that code is safe to merge. Keep human review and deterministic scanners in the loop for consequential changes.
LangChain compares Jev with language-model judges across accuracy, repeatability, latency and cost as an alternative way to evaluate agent behavior.
A faster judge is useful only when its rubric and labels track the behavior a team cares about. Benchmark findings should be reproduced on each application’s own data.
Hugo Duprez demonstrates Jev producing structured decisions that a game engine uses to build level sections during play.
Jev selects within the game’s schema; the engine still enforces valid geometry, difficulty limits and playable transitions. Speed figures remain creator-reported.
Duncan sends the maze state as JSON and lets Jev choose a direction when Pac-Man reaches a junction. The game engine then applies that bounded decision in real time.
Games make repeated, time-sensitive decisions visible. The demo illustrates the control loop, not a general claim that Jev sees or understands raw game video.
Rob Hallam presents a SuperX demo that asks many fixed questions about each post and uses the answers to rank drafts. It is an example of using scores to guide editing rather than generate the post.
Ranking is only useful if it correlates with later outcomes. Treat the creator’s performance figures as a demo claim until independently reproduced.
Stav Zilbershtein demonstrates classifying a large ad library by customer-journey stage and creative style, then using those labels to inspect a competitor’s campaign mix.
Consistent labels make a large collection easier to compare. The post’s timing and cost are creator-reported; the deeper account analysis is part of the wider workflow, not necessarily a Jev output.
Chris Tate combines json-render with Jev so a request can be mapped to components, actions and design-system options supplied by the application. The demo renders the selected interface in milliseconds.
Jev selects from application-defined building blocks; it does not generate unrestricted interface code. The speed shown is a creator-reported demo result.
Jarrod Watts sends an asset-pair price feed to Jev for a typed buy-or-sell decision, then application code places real orders on Kuru’s on-chain order book on Monad.
This demonstrates a fast typed decision inside an execution loop, not a profitable strategy. Risk limits, abstention, evaluation and key security remain application responsibilities.
Zachi demonstrates a PostgreSQL extension that evaluates rows with a natural-language condition through Jev, then caches the result for repeated queries.
Judgment-heavy filters can complement SQL, while exact facts and sensitive attributes still need deterministic rules and review. The timing and cost figures are creator-reported for one demo.
Nailthy Tang demonstrates a Drape prototype that combines a spoken request and the current outfit, lets Jev select an item from a prepared closet, then updates the virtual try-on.
Jev chooses among existing items; the surrounding application handles speech, assets and rendering. The reported latency and cost come from the creator’s demo.
Leo demonstrates Jev selecting traffic-light states across a simulated city while the application measures vehicle wait times.
This is a visual simulation, not evidence for real-world traffic control. The reported wait-time improvement depends on the creator’s comparison baseline and requires independent evaluation.
Test a structured decision in the Playground, then explore open-source integrations and examples in Projects.
Track new projects, System One community models, and practical use cases through frequent public updates or an occasional curated email.