Browser Use
@browser_use
Luna (planner) -> Jev (actor) playing poker and winning
XGames and real time
Agents that run on Jev instead of screenshots: Browser Use, Playwright and Stagehand builds, each with the speed and cost its author reported.
181 builds · page 6 of 6
These products pay for the directory. Want yours up here?
Browser Use
@browser_use
Luna (planner) -> Jev (actor) playing poker and winning
XGames and real time
Ricker
@0xRicker
Jev Engineering turns a static agent workflow into a graph that can rewrite itself while running. the video is basically the problem at scale: hundreds of routes → thousands of crossings → different agents → different tools → different confidence levels Jev Engineering doesn’t control every step. it controls the crossings. when two paths compete: → score both → kill the weak route → reroute the task so instead of one fixed chain, you get a live braid: state → decision → parallel paths → crossings → Jev → next state that’s the point of Jev Engineering: more parallel execution without letting the system lose the objective. the agents create the paths. Jev decides which paths survive. full breakdown below ↓
XAgents and browsers
nicolay
@nicolaycz
Jev is the semantic if in your agent loop. LLM writes. Jev (TypeSafe System One) answers typed questions on the same state (Noul, Choice, Score) with calibrated probs. Your code branches. Pull the cheap decisions out of the LLM. Early access: console.typesafe.ai
XAgents and browsers

Live siteOpen source
Typed decisions about text, web pages and screenshots, within 2 points of Jev.
OpenJev
84.0% (Jev 85.4%)
Live siteOpen source
Decision models for browser agents with a selectable compute depth.
APUS AI Lab
85.0% (Jev API 82.5%)
Live siteOpen source
Laya fine-tuned into the decision head of a browser agent.
cklxx
100% (54/54)David K 🎹
@DavidKPiano
I mixed Jev + an espresso (state) machine. Turns out, Jev's a pretty good barista ☕ Introducing Jevspresso: XState determines what's possible, Jev decides the next move. Order in plain language, or break stuff and watch Jev cope. Try it: jevspresso.dev
Sumanth
@Sumanth_077
I built a data analyst agent with Jev as the review layer! Qwen handles the main agent work, Jev acts as the review layer, and Vercel eve runs the agent loop, tool execution, and human approval flow. The agent takes a plain-English question about the data, inspects the database schema, writes the SQL, runs the query, and explains the result. The interesting part is what happens around that main loop. Qwen is responsible for generating the SQL and the final answer, while Jev reviews the parts where semantic judgment is actually useful. Anything that can be checked reliably with code stays deterministic. Jev reviews the agent at three points: - Before the agent starts, it checks whether the user's question is clear enough to answer from the available data. - After Qwen generates the SQL, it checks whether the query actually represents what the user asked. - After the query runs, it checks whether the final explanation is grounded in the returned rows. For example, we tested it with: “Who is our best customer?” The question sounds simple, but “best” could mean highest revenue, most purchases, highest average order value, or something else. Instead of letting Qwen silently choose a metric, Jev flagged the question as ambiguous and asked for clarification. The same separation applies to SQL execution. Qwen can propose a query, but it cannot decide whether that query is safe to run. The tool accepts only a single read-only `SELECT`, SQLite runs in read-only mode, results are capped at 200 rows, and queries without a `WHERE` clause can require human approval before execution. Those checks do not need another model call. But a query can be completely safe and still answer the wrong question. A deterministic rule can verify that the SQL is read-only. It cannot reliably judge whether a query for “revenue last month” accidentally calculates revenue across all time. That is where Jev comes in. It reviews the proposed SQL against the original question and schema before execution. After the rows come back and Qwen writes the explanation, Jev reviews that answer again to check whether the claims are actually supported by the returned data. The project uses a local SQLite sales database, Qwen through the Vercel AI Gateway, Gradio for the interface, and only two database tools: "inspect_schema" and "run_sql". No single model is responsible for everything. Qwen generates, Jev reviews, deterministic code controls execution, and Vercel eve manages the agent loop and approval flow. GitHub Repo: https://github.com/Sumanth077/Hands-On-AI-Engineering/tree/main/ai_agents/nl_data_analyst_agent 100% open source.
XAgents and browsers
Simon Shg
@ShengSSX
2 AI colleagues just booked us a demo off someone's random post online Ava and Owen are the two agents running our prospecting in @Parall_HQ. they live in our @Parall_HQ workspace like everyone else on the sales team, and @typesafeai Jev makes the quick judgement calls for them > Jev reads every post, Ava wakes up only for the ones that fit us > Jev rates every account, Ava only works the best ones > Owen writes the email, our human AE approves > Jev sorts the replies, Owen only chases the interested ones you don’t need to hand them leads. jevable makes it possible for proactive agents to own a job at 86% less cost than agents that check in every 30 min
GitHubAgents and browsers

GitHubAgents and browsers
Browser use where Jev picks one action per step and code owns the loop.
jkudish
336
GitHubAgents and browsers
Give an agent a model idea and get a LEGO model in LDraw.
anteloc
357GitHubAgents and browsers
A 3D interior level designer where a yes/no model presses the buttons.
yeme-oss
0Akshay 🚀
@akshay_pachaar
i just put Jev inside an open agent harness. (150x cheaper decision-making than LLM) agents burn a lot of tokens on decisions that are really just picking one option from a short list, like matching a client request to the right GitHub issue. so i built a weekly client follow-up agent that does exactly that. i tested it on 40 requests, and it was as accurate as letting Opus make every match, at 150x lower decision cost. here's the tech stack i used: → TrueForge as the agent harness → Jev for the matching decisions → Daytona as the sandbox for code execution Jev is a decision model from TypeSafe AI. it takes the options from your app and returns a structured choice with a calibrated confidence score, without generating any text. that confidence decides what gets a second look. low-confidence matches go back to Opus for review, and in my test, that review caught 5 wrong matches that would otherwise have gone through. TrueForge is TrueFoundry's harness, and it keeps context small. it loads tool definitions only when needed, writes large tool outputs to files, and lets the agent process data in scripts instead of the conversation. on DevRev's Enterprise Bench, it solved about as many tasks as Claude Managed Agents on roughly a third of the tokens. it also keeps credentials outside the sandbox and holds every write for approval. if you want to try this out, TrueForge is fully open source (MIT-licensed) and runs on your own machine with a single command. TrueForge GitHub: https://github.com/truefoundry/trueforge (don't forget to star 🌟) to help you reproduce my work and understand all the integration details, i wrote a detailed article. it's quoted below.
XAgents and browsers
AJ Asver
@_aj
Every day this week, we're launching a new feature @GrepdotAI to help you automate the work that's slowing down your business. 𝗗𝗮𝘆 𝟮: 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗼𝘂𝘁𝗽𝘂𝘁𝘀 𝗽𝗼𝘄𝗲𝗿𝗲𝗱 𝗯𝘆 𝗝𝗲𝘃 Customers often ask why our agents don't attach confidence levels to their recommendations. My answer has been that LLM confidence levels don't mean much. The model writes a number after the answer, predicting what a confident-sounding score looks like, with a bias toward making humans happy. RLHF pushes models overconfident. Decision models like Jev by @typesafeai change that. You declare the options up front. Jev returns a probability for each one in a single pass, plus a confidence score derived from how concentrated that distribution is. TypeSafe trained it with RLCD, which rewards calibration instead of rater approval, so decisions at 0.9 should be right about 90% of the time. In Grep, you can now build agents that use frontier models for the research and diligence, then hand their findings to Jev to make the final decision against your criteria. You set the threshold: above it the agent acts, below it a human reviews.
XAgents and browsers
GitHubAgents and browsers
A Jev browser agent for Claude Code. One Go binary, no Playwright.
barockok
4GitHubAgents and browsers
Jev reads a page’s HTML and names the CAPTCHA on it.
Michael Mintz
2