75 examples
Software Automation
Browser Use
13
Jev Ultrafast is an open-source browser agent that swaps screenshot-driven loops for a dynamic indexed DOM action space with one decision per request, completing a Google Flights search in 7.1s for $0.0039.
A browser-use agent autonomously plays Wiki Race, navigating from the "Coffee" Wikipedia page to "Artificial Intelligence" via an agent–browser interaction loop.
A smart clipboard agent that reads clipboard contents and web page context to automatically match and paste the right values into each form field.
A demo pairing jev with kernel-level browser use delivers blazing-fast, real-time in-browser agent actions.
A browser agent sprinted from Lionel Messi to Sam Altman on Browserbase in 9.7 seconds, beating a rival agent’s 20.4-second run at one-third the cost.
A tiny open-source browser agent that regenerates its action space every step from live DOM state—falling back to a small LLM for typing—finds flights in 7 seconds for $0.0039, demoed in real time at 1x speed.
A typesafe Jev-powered browser extension auto-completes entire job applications for $0.0013 each, enabling 1,000 applications for under a dollar.
An open-source framework for running end-to-end tests with AI agents, supporting web and mobile platforms, is launching soon.
JEV analyzed 3M replay events across 3,247 sessions in 40 seconds—flagging 132 rage clicks, 116 dead clicks, and 95 JS errors, auto-opening 213 fix PRs for $2.17—with severity ranking, per-bug session counts, and repro steps.
A voice-controlled browser shipped as a standalone exe pairs Jev with a local LLM fallback for everything it can't do, demoed booking a hotel and playing Wikirace at superhuman speed.
JevFill is an MIT-licensed unpacked Chrome extension that uses TypeSafe's Jev to map freeform plaintext notes onto web form fields, highlighting filled fields green for review while never sending or filling password/payment inputs.
An agent drives a browser by compressing each DOM into an element table, letting an LLM pick the action and element per step via a single OpenRouter call—no screenshots, ~200 bytes and ~$0.0001 per step.
A custom Chrome extension built with TypeSafe AI "Jev" auto-fills a 15-field form in just 1.2 seconds by skipping text generation and returning only structured data — a perfect match for browser automation.
Computer Use
8
A faster headless Computer Use loop: the LLM keeps memory/context, agent-desktop captures snapshots, and Jev selects the exact UI element to actuate—cursor-enabled with opencode.
AXe pairs the Jev model with natural-language instructions to autonomously drive an iOS simulator—opening Calendar, navigating to a target date, and creating and saving a named event—for just $0.006 per task, with further efficiency gains expected.
A computer-use agent demo performing interface actions 100x faster than LLM-based approaches, showcasing near-instant GUI automation.
Fully local computer use: an on-device CoreML model segments UI elements, OCR reads their labels, and a click-probability loop picks and clicks targets at ~90ms per decision—no screenshots, DOM, or LLM calls leaving the Mac.
A voice-controlled computer-use agent for macOS, built on typesafe's Jev, executes dictated commands like "open the notes app and create…" with sub-sentence latency — the app launches before the user finishes speaking.
A keyboard-first diagram editor lets a constrained AI build diagrams from plain English by picking among typed options every ~0.6s—each choice mapped to keystrokes—showing constrained agents excel when the UI is designed around them.
An open-source Android agent autonomously drove a phone — navigating a fresh action space each step via the accessibility tree (zero screenshots) with a tiny LLM typing fallback — to open YouTube and subscribe to MrBeast in 32 seconds across 17 steps in real time.
A 15-cloud-computer newsroom wall in Orgo streams sites like Hacker News, GitHub Trending, status pages, and npm advisories, while an agent reads every headline, rings a bell when something's urgent, and auto-opens the story.
Workflow Guardrails
17
A native Rust app watches live computer network traffic and flags anomalies in real time using a low-latency model where an LLM would be too slow, shipped with a purpose-built Rust SDK.
An open-source tool called Jev scores every coding-agent turn against uncodifiable rules a linter can't enforce, then tells the agent exactly what to fix ASAP.
A safety guardrails demo showing real-time risk warnings that appear mid-typing and adapt instantly as `rm -rf ./build` becomes `rm -rf /`, validated on a 200-command labeled dataset with results benchmarked in the video.
A demo showcases rapid AI-driven app testing by pairing the Jev typesafe testing library with the OpenCode agent, promising dramatically faster test iteration for quality gating.
A live demo of a fast, accurate AI content moderation guard built on typesafe's jev library, showcased for compliance and auditing workflows.
Content-aware PII redaction runs inside Postgres via a `redact()` SQL function, using Jev to tag names, emails, phones, addresses, and IDs so only sensitive spans are masked per role (guest/support/admin) while the rest of each message stays readable and uncleared data never leaves the database.
tenet is an agentic code review gate that evaluates commits, commit messages, and PRs against plain-language rules (sourced from community anti-slop skills, auto-generated from AGENTS.md/CLAUDE.md, or custom presets), blocking an agent's four violations in 1.07s for $0.0003 so it self-corrects.
Sparky swaps Firebase security rules for an LLM gatekeeper that decides whether you can read his diary — a deliberately terrible demo of AI-as-access-control (not for prod).
A vibe-coded Jev-based safety layer that judges whether a robot should be permitted to execute a human's instruction before acting, adding a guardrail checkpoint to the robot control workflow.
An agent gates every proposed action through Jev, a millisecond conscience that scores reversibility, budget, data support, downside, prior rejections, and confidence for ~$0.001 per decision—holding on any red flag and alerting the user.
A typesafe "system one" model was tested doing file-by-file vulnerability review of the Linux 6.12 LTS kernel tree, delivering striking speed and lower false-positive rates than Luna and other small fast models.
A Jev-based linter that quality-gates marketing copy by flagging clichéd filler phrases like "trusted by thousands" before publication.
Inspired by @hackgoofer & @rauchg to use AI for real workflows. Got access to @typesafeai and built an autonomous DB Migration Guardian. 🛡️ It intercepts Prisma SQL plans. I
An intent-aware opencode permissions plugin that enforces natural-language rules — e.g., blocking every domain except Google — catching all routes an agent tries without predicting each shell command.
A massively parallel browser-based adversarial testing suite automatically stress-tests every release for just pennies per run.
Demo shows "Jev" embedded in a clinical workflow: OpenMed reads 6 condition mentions in context, the agent makes 6 typed decisions, and deterministic code guardrails admit 1 to the problem list, block 4, and route 1 to human review.
Test-driving Jev as a health-insurance chatbot bouncer that classifies and routes messages scored 94% (98% block precision) on 200 unseen scenarios at ~778ms latency for under a cent—turning safety judgment into a sub-cent API call.
Financial
17
AI trading agent reads an asset-pair price feed, decides buy/sell, and executes real orders on Kuru’s on-chain order book via Monad within each 300ms block.
Jev demonstrates an AI trading agent that ingests dozens of structured market signals and converts them into intelligent, real-time trading decisions.
A demo site built on Jev that ingests every new SEC 8-K filing in real time and classifies what happened and whether it's good news in ~300ms per filing.
jevscan is a Chrome extension that uses Jev from @typesafeai to flag malicious addresses and transactions on Etherscan in real time.
A pipeline runs LLM trading decisions (1,155 calls, 3 strategies, 5 assets, 77 days, $0.09, 87s, 1.1s/call) then uses a 124B MoE vision model (~5.5B active) to convert a design mockup into a Playwright-rendered 13s dashboard video.
A single LLM call extracts asset, direction, and strike—each with a probability—from a Polymarket question in 640 ms, auditing 9,916 questions for $0.46 and flagging 2,015 candidate misses in a regex parser.
An AI agent treats binary event-contract prices as probabilities, disagrees with the book via sub-second reactive onchain events, tracks 70K events in 10s, and improves Brier from 0.311 to 0.212 on testnet.
Jev plugged into an AI hedge fund pipeline (set strategy → pick tickers → backtest) delivers frontier-level trading decisions 100x faster and cheaper than an LLM, cutting backtests from minutes to seconds.
JEVINIK evaluates stocks insanely fast by pulling market data, signals, risk, and filings via Jev (no LLMs) on Valyu's financial data to predict the next 30 days as bullish or bearish.
TypeSafe AI's Jev streams live BTC/ETH/SOL market state into typed BUY/SELL/HOLD decisions executed every few hundred milliseconds, skipping chat and long reasoning traces entirely.
A demo wires the fast, low-cost "Jev" LLM into an automated crypto trading bot that wins only ~30% of trades yet still grows assets roughly 4% through asymmetric payoff.
Swapping a $4-per-500-pool LLM analyst for a $0.00007-per-call typed scorer let it evaluate all 340 pools in 190ms instead of filtering to 40 — surfacing winner #287 for +0.8 ETH and lifting win rate from 81% to 84%.
Feeding a single URL into typesafe.ai pulls live Asian market data, scores every signal with the jev model, and auto-generates a complete GTM plan via astra — all for $0.03.
A six-agent pipeline grades memecoin launches before pools open using schema-guaranteed typed outputs (not strings) with calibrated probabilities, making 70ms decisions across 100K launches/1.4M judgments at $0.042/M input tokens—flagging rugs, bundles, and snipes like a drain it refused 26 minutes early.
Swapping a 12-bot trading desk's narrative scorer for a 4-question typed-prompt call cut scoring latency from 2.3s to 190ms, capturing a 1 ETH memecoin entry the old pipeline would have missed.
A "bouncer" pre-filter that sits in front of trading agents — checking each signal for LLM-worthiness, prompt injection, and clarity before it gets through — blocked 23 bad trades and one injection attempt in a single night, boosting returns from +1.9 to +4.2 ETH.
A NERVE memecoin analyzer node pairs JEV's 190ms pool scoring with a four-layer pipeline emitting 14 typed, threshold-checked decisions per token at $0.001 each — flagging a rug at 0.93 confidence and dodging pools worth 4 ETH.
Pipeline Routing
20
Jev replaces prompt-based context compaction with instant relevance scoring of every tool call, dropping irrelevant ones to compress context at near-zero latency.
An AI director routes livestream context into real-time camera cuts, price-card overlays, model-delegated Q&A, off-topic filtering, and feature-verification flags—every routing decision rendered directly on screen for AI-run live shopping.
A realtime generative-UI demo where an LLM streams JSON-driven decisions to instantly pick and render the best shadcn component—e.g., choosing between a data table and a donut chart—for the given data.
Live demo of Jev, a decision-only model that returns typed probabilistic answers in parallel instead of generating text, responding in ~0.11s—roughly 75x faster than GPT-5.6 Terra—at about $42 per billion input tokens.
A demo of Jev, a model router that analyzes each request and automatically dispatches it to the best-fitting model.
An AI fitness coach rebuilt so a deterministic engine makes all coaching decisions while the LLM only renders natural-language text — cutting latency 8.2× (26.02s→3.16s) and cost 4.8× ($0.0032→$0.00065) per workout.
Speculative function calling that parses intent and arguments while you type and pre-executes the tool call the moment all parameters resolve — firing answers without waiting for an Enter keypress.
Minirouter/Fusion now classifies each request by task type and complexity to route it to a handpicked model, while Codex exposes presets/routers in the model picker and Claude Code auto-caches long prompts.
A Pipecat-orchestrated voice-driven UI decouples a fast command agent that manipulates the interface from a slower voice agent handling generation, staying snappy even across a London-to-us-west hop.
Jev is a deterministic Claude Code hook that routes tasks by complexity—mechanical work to Haiku, intelligent tasks to Opus sub-agents, long-running jobs to external harnesses like Codex—replacing brittle system-prompt-enforced routing.
Wender demo shows dual-speed LLM pipeline: a fast "Jev" pass instantly selects the relevant div to edit while the slower "Luna" model regenerates only that fragment, making small UI changes near-instant instead of re-rendering the full HTML.
Jev is a cheap, fast classification model emitting calibrated probabilities to gate human-in-the-loop or smarter-model dispatch, demoed via a site that answers questions with source URLs from a pre-loaded page.
An interactive demo where editing inputs live-updates classifications, showcasing a "combination input" approach that decomposes statements into classifications and routes each to the right model instead of brute-forcing everything through one LLM.
A tabular document-review demo where a cheap router model assigns pre-set category tags, escalates to a more expensive model only when warranted, and explicitly abstains rather than hallucinating a label when no tag fits.
instead of generating text, jev from @typesafeai generates structured output this makes it great for classification tasks like model routing, tool selection/search, and guardrails
A prompt-routing tool that auto-selects the agent, model, machine, and working folder per task—sending major rewrites to Fable + Claude Code and iOS app changes to a local Mac.
Jev auto-routes each prompt to the most fit image or video generation model on Higgsfield, automating per-request model selection for genAI pipelines.
A multi-model pipeline built a "keep the city on a whale alive" decision game where GPT-6 Astra designed the world, Jev chose actions, and H3 Max Turbo on fal rendered one decision per round to video — generating 264 clips in 5 minutes.
A typed decision layer for Pipecat voice pipelines that batches six semantic checks (turn-ending, intent routing, sarcasm at 0.92 confidence, frustration scoring) into two calls per turn—adding just 6 ms—so handoff fired on turn 5, three turns before the caller asked.
An AI-assisted cold-calling rig that auto-dials, classifies what's on the line (phone menu, voicemail, voice agent, or human), and live-matches the transcript to a decision tree to surface the next question on screen.