← すべてのユースケース

103 件の事例

ソフトウェア自動化

ブラウザ操作

18

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.

An open-source Chrome extension that detects Taobao/JD.com listings from merchants suspected of denying staff two-day weekends and stamps a "PASS" overlay on them as you scroll, letting shoppers vote with their wallets.

A JEV + Opus 5.5 live site redesigner rebuilds any pasted URL as you scroll: IntersectionObserver fires ~0.1s typed layout decisions, Opus streams TSX + CSS patches, redoing 8 sections in ~20s across ASCII/halftone/stipple styles.

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.

Embedded Jev into a service landing page so that user questions are classified in real time and instantly routed to the relevant slide.

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.

An autonomous browser agent scraped 4 rental sites in 1m16s for $0.0454, visiting 32 pages across 76 actions and 112 model calls to return 21 houses.

A browser agent ran one-sentence-per-step instructions across flights, Wikipedia, and a shop checkout in 34 seconds of unedited footage, autonomously stopping itself right before placing the order.

コンピュータ操作

12

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 that navigates automated phone systems (IVR menus), hardened to handle many real-world edge cases.

A Pomodoro focus app that asks a low-latency LLM whether every open window and tab relates to your declared task, then auto-closes off-task ones after a 4-second warning.

A computer-use agent demo performing interface actions 100x faster than LLM-based approaches, showcasing near-instant GUI automation.

A Mac app that classifies whistled melodies with the Jev model to trigger pre-registered desktop actions — bringing target apps to the foreground or firing complex Shortcuts workflows — all hands-free with a single whistle.

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.

A Jev-powered agent autonomously controlled an Android phone to navigate Uber — opening the app, entering a trip, and reaching the payment screen in just 9 actions over ~21 seconds.

ワークフローガードレール

22

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.

jev-lint is a fuzzy linter that hooks into coding agents after every edit, asking an LLM whether the new code breaks team rules—cutting violations from 2.38 to 1.21 per task across 96 Claude Code runs.

keel, a free MIT-licensed macOS coding workspace, lets a one-line agent pick route_b for a flaky date test, then distrusts its own pick—re-validating it live, letting a 0.99 score open zero doors, asking before risky calls, and giving the picker no credit for green tests.

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.

A low-cost, high-speed model ("Jev") powers a POC that scores command opsec in real time inside Mythic C2 and classifies expression types—promising for offensive security despite still-limited cyber skill.

A multi-agent coding dashboard gates every action through 12 typed risk checks, auto-shipping safe work while holding, escalating, or refusing risky changes—360 judgments at 311 ms each, $0.042 total, 61/61 tests green, 63% autonomous.

An 8-minute setup for an overnight X automation agent with typed human-approval gates, hard score thresholds (≥0.90 to run), and irreversible-action queuing executed 3,412 actions, blocked 47 injection/scam attempts, and cost $0.02.

金融自動化

29

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.

24/7 Rust prediction-market trading bot running on Opus 5.5 + Jev with a full open codebase, an 8-page guide to finding and sizing positions, and a Picsart pipeline auto-generating recap clips of winning trades — live 5 days with reportedly unreal returns.

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.

An AI agent transcribes live AFL Brownlow Medal audio to detect each vote, instantly re-simulates fair odds, and auto-places Betfair bets whenever a new edge emerges.

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.

A dual-model bot clones 100+ top memecoin wallets on Robinhood Chain—rescanning every 20s, filtering wash trades, scoring 536 wallets—then fires ≥80%-confidence $100 trades with hard stop-losses: 52,110 decisions in 21.6s for $0.37 API cost.

An open-source AI stock trader turned $100K into nearly $210K in a 2022 backtest, roughly doubling while beating the S&P 500’s ~60% gain using William O’Neil momentum rules with same-morning information only.

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.

Open-source terminal agent "Jev" trades Polymarket's 5-minute BTC Up/Down markets: each tick it reads market + spot state, emits a side with calibrated confidence, and a deterministic policy enters only above a hard confidence/edge gate once per window.

A concept trading desk where Grok agents compress a $1,513 order to $366 and a typed 70–500ms decision model limited to ENTER/WAIT/REDUCE/REJECT rejects on stale data, blocking any broker request and preserving the $7,318 paper account.

A crypto-trading pipeline remixing architectural patterns from 10 Jev agent repos — structured chain-state reads, deterministic honeypot checks, and adversarial vetting — scanned 200+ pools at 190ms each to print 1 ETH overnight.

A Solana memecoin pipeline fuses 10 borrowed architectures into typed JSON-in/JSON-out nodes that score liquidity/team/narrative/timing in one 190ms call, with nanosecond anti-honeypot reflexes and an adversarial checker, earning +3 ETH.

A wallet sandbox that interposes a policy agent before every send — auto-allowing an $18 domain renewal, blocking a $500 unknown bridge, and escalating a $65 new-vendor payment to a human — enforcing hard spend limits in code while the agent judges mandate fit and counterparty evidence.

A trading stack pairs Opus 5.5 for market analysis with JEV as a risk gate that sizes every position, blocks correlated exposure, downshifts to a cheaper model while watching charts, and enforces level-based exits—vetoing Opus's 10x BTC leverage down to 1x.

A paper-trading dashboard on Bitget USDT-M running $200 clips across 8 assets (crypto plus gold/silver), with live multi-timeframe charts, per-asset kill switches, net-vs-gross equity curves, fee/rebate accounting, and a real-time decision feed.

A Claude Opus 5.5-driven strategy ran Polymarket sports markets like a hedge fund—penny-priced longshot outrights, heavy bets on mispriced ~50/50s, and in-game trading—netting +$3.43M profit (max single win +$1.05M) on $117M volume.

パイプラインルーティング

22

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 jev2mcp demo uses jev to pre-route messy user prompts, automatically selecting and injecting the right MCPs, tools, and plugins into an agent's context so the agent never has to figure out its own tooling.

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.

Routing Claude Code's yes/no decisions through a cheap decision model cut three in-PR-loop checks from 13s to 0.83s, so a 31-question refactor stops burning essay-priced tokens on trivial confirmations.

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.

A $5/day AI agent budget manager that triages tasks across Claude tiers — routing small fixes to Haiku, batching calls near the cap, and deferring non-critical work overnight — cut daily spend from $38 to under $5 for 26 straight days.

元の投稿
元の投稿を読み込み中…X で見る ↗
jev
キーワードを入力してユースケースを検索。