awesome-jev

Awesome Jev

Public, source-linked examples of Jev, the decision model that TypeSafe AI released on 15 September 2026, used for robot control, 3D and animation work, and related control tasks. Each entry links the original post, names the author and date, quotes the author for every claim and number, and archives the demo video or images in this repository so they stay viewable if the originals disappear. Rights remain with the authors.

Every link was opened and every post read in full on 2026-09-19. Descriptions repeat what the posts say; where a post leaves something out (the robot model, whether a run is simulated, how images reach the model), the entry says so instead of guessing.

Contents

• About Jev
• Robot control on physical hardware (2)
• Robot control in simulation (8)
• 3D modeling, animation and virtual cameras (4)
• Vehicles, drones and games in simulation (9)
• Design tools and robotics data (3)
• Reported numbers
• GitHub projects
• Directories and coverage
• About the archived media
• Contributing

About Jev

Jev is the first “System One” model from TypeSafe AI, announced on 15 September 2026 by the company’s founder Diogo Almeida, “available today in early access” (launch post; announcement on X). The vendor’s own description: “Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” The model is trained with a method the company calls “Reinforcement Learning for Calibrated Decisions (RLCD)”.

Facts from the vendor’s documentation, read on 2026-09-19:

• Interface. One endpoint (POST /v1/systemone) with three question types: Noul (“A yes/no question. Returns the probability the answer is yes.”), Choice (“Picks one option from a set you define. Returns the chosen option and the full probability distribution.”) and Score (“Rates the state along a rubric you define.”) (API reference). “Jev supports a cardinality up to 255” (launch post).
• Input. “Text only. String, JSON object, or array of text values. No image, audio, or video input.” Context: “64k tokens per request; 32k tokens for state plus the longest question” (models page). This is why every robotics post below feeds Jev structured state rather than camera images.
• Versions. The current model is “Jev 1.13” (jev-1.13.0); jev-latest points to it. The docs advise pinning a version “If you have tuned confidence thresholds against a specific version” (models page).
• Price and limits. “$42 / $0.042” per billion / million input tokens, output tokens free; rate limits “250,000 tokens per second / 1,200 requests per minute”, which the page says “can change without notice” (models page).
• Speed and cost claims (vendor). “End-to-end response time is 70ms-500ms for TypeSafe.” The home page’s “193.6x Faster, 444.6x Cheaper” comes from the company’s own workflow measurements, which the launch post says “are on the higher end of real world gains” (launch post, home page).
• What “calibrated” means. “Calibration is measured across groups of predictions; it does not guarantee that an individual answer is correct.” The confidence value is meant for routing: “High confidence: Act automatically”, “Low confidence: Do not act. Route to a human, request clarification, or fall back to a different system.” (concepts, confidence).
• Known weak spots (vendor’s own list for jev-1.13, reviewed 2026-09-17). “It struggles with tasks that require numeric precision”, “Jev is not a calculator”, “jev-1.13 does not count reliably”, and “Jev suffers from context rot, so unrelated material in the state costs you accuracy” (model jaggedness page). The documentation pages checked contain no robotics or physical-safety guidance.

The posts below use Jev the same way: the application or simulator sends structured state (JSON, text or a menu of options), Jev returns one typed choice with a probability, and separate code executes the motion or edit. Several authors say so explicitly (Isaac Sin, Dmytro Hrybov, the Askable Arm README).

Robot control on physical hardware

The two posts whose videos show a real robot. Both authors describe Jev choosing moves without a trained policy.

Preview	Case
	SO-101 arm picks up a ball and places it in a bowl Daniiar Abdiev (@DaniiarAbdiev), X, 2026-09-18 Author: “Two USB cameras, an SO-101, and @typesafeai’s Jev choosing the next move at ~2 decisions a second. After a slip and some debugging, it went back for the ball and got it into the bowl.” The video carries the captions “Supervised prototype” and “Edited real footage”. How camera images are turned into Jev inputs is not described in the post. Setup: physical SO-101 arm, two USB cameras · Archived copy: video, 63 s
	Zero-shot control of a physical robot arm, no trained policy Zaid Bulbul (@zaidbul), X, 2026-09-18 Author: “have not seen anyone actually using Jev for robotics outside of a simulation, so here is Jev running with no policy, zero-shot controlling the robotic arm.” The post names neither the arm nor the action interface. Setup: physical robot arm on a tagged grid mat (model not named in the post) · Archived copy: video, 49 s

Robot control in simulation

Jev picks discrete actions or targets from structured state; the simulator or a script executes them. Environments were checked in the archived videos.

Preview	Case
	Askable Arm: plain-English goals chained from hard-coded primitives Tarun Tomar, LinkedIn, 2026-09-18 Post: “Give it a goal in plain English. Jev chains a set of hard-coded primitives. The arm does the thing.” The repository’s README adds the details: a “menu of ~30 primitives”, “Jev never outputs torques or a trajectory. It picks one primitive per step”, “No images go to Jev” (it receives privileged simulator state), ManiSkill tasks PickCube-v1 and ResetButton-v7 at seed 0, and “~1 second per Jev pick”. Setup: ManiSkill simulation, Franka Panda · Archived copy: video, 111 s Links: code (jev-askable-arm)
	Two calls per step: what to do, then how to move Dmytro Hrybov (@dimentary), X, 2026-09-18 Author: “tested Jev as a real-time robotics policy in MuJoCo. it struggled at first, so i split each update into two calls: decide what to do next, then decide how to move the arm and gripper.” On inputs: “Jev doesn’t accept images, it gets simplified geometry and contacts as text here.” Setup: MuJoCo robot-arm simulation · Archived copy: video, 20 s
	MakerMods Metal arm in MuJoCo: typed actions with confidence Isaac Sin (@IsaacSin12), X, 2026-09-18 The simulator passes scene state to Jev as JSON; the camera image is not passed. Jev “picks the next bounded action (hover, descend, grasp, lift, place) as a typed choice with a confidence score”. For “Put the red apple in the blue bin” the author reports “9 decisions at ~150 ms each”, and that Jev “refuses tasks it can’t map to the scene instead of guessing”. Setup: MuJoCo simulation of the MakerMods Metal arm · Archived copy: video, 36 s
	Jev, GPT-6 Astra and GPT-4.1 mini on an apple-to-plate task OpenRoboto (@openroboto), X, 2026-09-19 Post: “We compared Jev, GPT-6 Astra and GPT-4.1 mini in MuJoCo. One apple. One plate. Each model chooses intent → X/Y/Z direction + gripper open/hold/close.” The team’s repository gives the numbers: Jev 1.13 placed the apple in 113 decision cycles for $0.018825; GPT-6 Astra placed it in 106 cycles for $5.933624; GPT-4.1 mini reached the 160-cycle limit. The repository states “These are one seed-0 trial per controller, not success-rate estimates” and that the observations “are not camera perception”; the video captions add “GPT-6 reasoning: low” and “Displayed probabilities have different sources; neither is calibrated task-success confidence.” Setup: MuJoCo manipulation simulation · Archived copy: video, 59 s Links: code and results (openroboto-ai/jev-robot-control) · mirror (RobotWorld)
	MOSS litter-picking: Jev chooses the target, replayed in simulation metr0x (@metrox_eth), X, 2026-09-18 Author: “Jev picks the target. MOSS picks up the litter. ‘Pick up the cans.’ Now change the instruction: ‘Pick up the bottles.’ Real Jev decisions, replayed in simulation.” The project page describes the loop as “Structured state → Jev → robot action” using “recorded API responses”. The repository README states: “The three decisions shown are real API responses recorded on 17 September 2026 and replayed in the browser.” and “Nothing here calls an API: it is a recorded run, kinematic animation, simulated object labels, no camera perception, no physics validation.” Setup: static browser replay of recorded Jev decisions (kinematic animation) · Archived copy: video, 18 s Links: project page (MOSS × JEV) · code and recorded-run README (metrox-eth/moss-jev)
	Multi-stage manipulation with confidence gates Jony Shaik (@JonyShaik), X, 2026-09-18 Author: “Jev handles the high-level task transitions and confidence gating at each boundary, while deterministic physics guards manage execution.” The video shows a simulated humanoid pouring at a table, with a skill list and guard messages on screen. Setup: simulated humanoid at a table (per the video; the post does not say) · Archived copy: video, 53 s
	Early robot-arm experiment Arpan (@ArpanTripathi20), X, 2026-09-18 Author: “Seems Jev can control robot arms. Need more iterations to make its degrees of freedom broader.” Nothing more is stated in the post; the video shows a simulated arm placing objects on a table with a chat panel beside it. Setup: simulated arm in a browser-style interface (per the video; the post gives no details) · Archived copy: video, 28 s
	Microduck navigates around obstacles to a goal ostyn (@ostynhyss), X, 2026-09-18 Author: “I plugged Jev into a version of @huggingface Microduck and it can navigate environments with obstacles to reach a goal destination!” On cost: “I played around in this project for hours, accross multiple days, and only spent $0.34.” Sensors and the low-level controller are not described. Setup: a version of Hugging Face’s Microduck in a simulated room (per the video) · Archived copy: video, 32 s

3D modeling, animation and virtual cameras

Jev as an evaluator, an animation orchestrator, an agent brain and a camera planner.

Preview	Case
	Blender airplane model, with Jev as the evaluation standard Har (@Sxfyhvx), X, 2026-09-18 Author: a chat model reached through OpenCode was asked “to help me create a 3D airplane model in Blender, using JEV as the evaluation standard. The results are really impressive.” Jev’s role here is evaluation; the geometry comes from the other model. Setup: Blender, OpenCode, a separate chat model · Archived copy: video, 8 s
	A 3D character’s whole performance, ten decisions per message Joao Bortotti (@john_bortotti), X, 2026-09-18 Author: “I’m using @typesafeai’s Jev to orchestrate a 3D character’s entire performance. Mouth, brows, eyes, cheeks, gaze and body: ten decisions per message, composed live into one coherent reaction. No preset expressions.” Setup: interactive 3D character (Mutuals) · Archived copy: video, 26 s
	500 real-time agents in one 3D environment Cris Lenta (@crislenta), X, 2026-09-17 Author: “500 real-time agents running in parallel in a 3D environment”; preliminary numbers “500ms average latency, 35 API calls/s, all with a naive implementation. We did 0 optimizations!” The agents’ decisions, not the 3D assets, come from Jev. Setup: 3D multi-agent scene · Archived copy: video, 24 s
	Natural-language camera moves for a video editing tool Alex Carrabre (@carrabre), X, 2026-09-18 Author: “Jev converts natural language to precise camera movements (ie spelling ASTRA) by answering a few calibrated multiple-choice questions (move kind, plus direction and magnitude band per camera axis) By creating keyframes it emits a structured trajectory (time/azimuth/elevation/distance) and it’s checked before rendering”. The post also claims “~230x faster planning” without stating the baseline. Setup: editing tool built on mint.gg · Archived copy: video, 41 s

Vehicles, drones and games in simulation

Control loops in simulators and games, including decision games where Jev picks the next move. None of these involves a real vehicle or aircraft.

Preview	Case
	A driving simulator built around Jev Justin Schroeder (@jpschroeder), X, 2026-09-16 Author: “I rebuilt Tesla Full Self Driving with Jev in less than an hour.” The post has no further technical detail; the video shows a simulated car. This is not a claim about a real vehicle. Setup: driving simulator (see the video) · Archived copy: video, 120 s
	Discrete driving decisions from live environment state Cipher (@cipherwrk), X, 2026-09-18 Author: the system “receives real time data from its environment & decides what to do next. Change lanes, Brake, Accelerate, Slow down. With sudden obstacles, pedestrians, traffic & red lights.” The author calls it “A small experiment in what decision native AI can look like”. Setup: driving simulator (see the video) · Archived copy: video, 116 s
	Virtual drone through an asteroid field, with a fallback to a larger model Mahmoud (@MKhordoo), X, 2026-09-18 Author: “300ms decisions. Left / right / slow / accelerate.” The overlay shows “Green = Jev’s own confidence. Purple = ‘I’m not sure, ask the big model.’” and “99% of the time, Jev steered the drone on its own”; “the larger model only steps in when uncertainty is high”. Setup: virtual asteroid-field environment · Archived copy: video, 37 s
	Jev flies a rocket in Kerbal Space Program TextLayer (@textlayerai), X, 2026-09-18 Post: “Gareth, our AI Architect, did the obvious thing: gave @typesafeai’s Jev control of a rocket in Kerbal Space Program. TL;DR: this is very cool. His learnings in the comments.” The comments were not read. Setup: Kerbal Space Program · Archived copy: video, 124 s
	Whale-city decision game with generated video gokaygokay (@gokayfem), X, 2026-09-18 Author: “I created a complex decision making game with Astra. It is about keeping the city on a whale alive with decisions.” The post assigns the roles: “GPT 6 Astra designed the world”, “Jev chose the actions” and “H3 Max Turbo on fal turned one decision from each round into video”. Its claim that “All of the Jev decision making and video generations took only 5 minutes for 264 clips” concerns the combined workflow; no Jev-only timing or question schema is stated. Setup: author-described decision-making game; generated video, no physical robot or verified 3D engine · Archived copy: video, 198 s
	Sentinel tactical decisions against a player Adi (@aditya005), X, 2026-09-18 Author: “JEV Live: hands the Sentinel’s tactical call to JEV.” The post compares that mode with a “fixed chain of if/else rules” and reports, “It went and covered the exit.” The comparison uses the “same available moves”; no trial count, success rate or decision-input schema is stated. Setup: browser grid game · Archived copy: video, 78 s
	Manhattan pathfinding with Jev preferences Shivam Chauhan (@BuilderShivam), X, 2026-09-18 Author: “Can Jev defeat Dijkstra’s or even the Mighty A*? Let’s check it out on Manhattan!” The attached comparison labels the Jev search with “JEV SUPPLIES THE PREFERENCES”. A spatial route-planning example; the post does not document the API state, question schema or a controlled performance benchmark. Setup: graph-search visualization on a Manhattan map · Archived copy: video, 34 s
	Chaotic kitchen priority decisions JollyRojak (@Michael50663932), X, 2026-09-18 Author: “I built a chaotic kitchen to stress-test Jev.” The setup has “4 chefs”, “Expiring orders” and “The occasional fire”. The post reports, “In an early live test, Jev gave firefighting a 66% probability over finishing the order at 33%, then returned its move in ~200ms warm.” Those are one early test’s stated probabilities and latency; no success rate is reported. Setup: simulated kitchen game · Archived copy: video, 16 s Links: live demo
	A solo Jev Minecraft test in a launch review video MattVidPro, YouTube, 2026-09-18 MattVidPro asks, “what happens when I give it an open-ended game like Minecraft?” and labels a chapter “9:06 My solo Jev Minecraft test”. The description says, “I compare Jev’s strengths in simple action spaces, computer use, robotics, and a Minecraft setup built with Astra.” The action interface, model version and result are not stated in the description; only the platform thumbnail is archived. Setup: Minecraft setup built with Astra; creator-described, video not watched · Archived copy: image

Design tools and robotics data

Design-tool control and offline evaluation of robot data.

Preview	Case
	Controlling Figma by voice mikegee (@mikegee), X, 2026-09-18 Author: “Controlling Figma with voice using Jev from @typesafeai. Total cost from first line of code to recording this video: $0.01.” The speech and execution pipeline is not described. Setup: Figma · Archived copy: video, 33 s
	Figma plugin that checks designs against a requirements document Furkan (@W33baker), X, 2026-09-18 Author: “you give it a requirements doc, select your frames, and it tells you which requirements actually show up in the designs and which don’t. Seems pretty good honestly.” Setup: Figma plugin · Archived copy: video, 33 s
	Evaluating humanoid teleoperation data: label consistency and segmentation Anto Patrex, LinkedIn, 2026-09-19 Author: “We ran TypeSafe AI’s JEV eval model on humanoid-robot teleop data from deployment sites. 99% label consistency. 91% annotation completeness.” A “42s bimanual task” was split “into 20 segments: approach, grasp, lift, move, place, three times over”, with “98.5% of the timeline labeled. Zero overlaps. 33ms gaps”. The author’s caveat: “‘n’ is minimum, and it’s a sorting task”. Offline data evaluation, not robot control. Setup: recorded humanoid-robot teleoperation data · Archived copy: image 1 · image 2 · image 3

Reported numbers

Every number was read at the linked source on 2026-09-19. Vendor-reported figures are marked; the rest are single recorded runs or author reports, not success rates.

Vendor evaluation

Result	Setting	Source
Jev, workflow: 67.8% agreement, $0.0004, 0.4 s; compared in the same table with opus 5 (73.1%, $0.1761, 37.8 s), sol (74.1%, $0.0836, 23.3 s) and terra (67.9%, $0.0304, 10.1 s)	TypeSafe’s own harness; “the reference labels are generated via an average of the responses of GPT-6 Astra and Claude Fable 5.1, both at high thinking”	evals.typesafe.ai (vendor-reported)

Independent measurements in simulation

Result	Setting	Who	Source
Jev 1.13: placed, 113 cycles, 226 calls, $0.018825, 181.847 s wall time; GPT-6 Astra: placed, 106 cycles, 212 calls, $5.933624, 707.274 s; GPT-4.1 mini: “160-cycle limit reached”, $0.288512	MuJoCo apple-to-plate task; “one seed-0 trial per controller, not success-rate estimates”; inputs “are not camera perception”; GPT-6 at low reasoning per the video	OpenRoboto	results file, post
Jev: stacked in 19.1 s for $0.0006; Claude Opus 5: stacked in 158.8 s for $0.75 (“That Opus run needed one retry; clean first-try Opus runs took about 55 s and $0.19”)	MuJoCo Franka and Allegro hand, cube stacking; “One recorded run each”	Fazal Ali	README
With Jev engaged the drone reached “77.5 m (whole course)” against 17.7 m in three baseline runs; “80 calls over 65 s, 0.11 s median latency”; the author adds that on “an earlier, simpler arena a matched 3-seed comparison showed no advantage for Jev”	MuJoCo, Skydio X2 model, Jev at about 2.5 Hz with a 50 Hz reflex layer that “keeps the veto”	Roman Slack	README

Author-reported numbers in the posts above

Number	What it describes	Reported by	Source
~2 decisions per second	next-move rate on a physical SO-101 arm	Daniiar Abdiev	X, 2026-09-18
9 decisions at ~150 ms each	“Put the red apple in the blue bin” on a simulated MakerMods Metal arm	Isaac Sin	X, 2026-09-18
~1 second per Jev pick	one primitive chosen per step on a simulated Franka Panda	Tarun Tomar	README
300 ms decisions; “99% of the time, Jev steered the drone on its own”	virtual drone in an asteroid field, with a larger-model fallback	Mahmoud	X, 2026-09-18
500 agents; 500 ms average latency; 35 API calls/s	real-time agents in a 3D environment, “naive implementation”	Cris Lenta	X, 2026-09-17
ten decisions per message	facial and body performance of a 3D character	Joao Bortotti	X, 2026-09-18
“~230x faster planning” (baseline not stated)	camera planning in an editing tool	Alex Carrabre	X, 2026-09-18
$0.34 over hours of use across multiple days	Microduck navigation experiments	ostyn	X, 2026-09-18
$0.01 “from first line of code to recording this video”	voice control of Figma	mikegee	X, 2026-09-18
99% label consistency; 91% annotation completeness; 98.5% of the timeline labeled; 33 ms gaps	humanoid teleoperation data, small sample (“‘n’ is minimum”)	Anto Patrex	LinkedIn, 2026-09-19

No peer-reviewed evaluation of Jev was found: searches of arXiv for “TypeSafe” and “Jev” on 2026-09-19 returned nothing.

GitHub projects

Repositories that use Jev for robots, simulators or 3D scenes; each README was read on 2026-09-19.

• TarunTomar122/jev-askable-arm: simulated Franka in ManiSkill; “Jev never outputs torques or a trajectory. It picks one primitive per step.” Linked from the LinkedIn post above.
• openroboto-ai/jev-robot-control: the MuJoCo apple-to-plate comparison above, with prompts, recordings and a results file; “New trials call OpenRouter”.
• FazalAAli/jev-robotics-demo: “Jev (TypeSafe System One) vs Claude Opus 5 driving a simulated robot arm in MuJoCo”; “Jev picks the move, decides when to grasp and release, and decides when the task is done.”
• RomanSlack/jev-drone: “Camera-only autonomous drone in MuJoCo with a small judgment model (TypeSafe Jev) in the loop at 2.5Hz”; “Jev is not a vision model. It takes JSON and returns typed answers with probabilities.”
• kxzk/typesafe-jev-drone-demo: “A live Three.js drone simulation with a fully typed Python/FastAPI backend. TypeSafe’s jev-latest chooses each navigation action”.
• AliUraish/Jev_SO101: prototype for an SO-101 where “Astra interprets both views, Jev selects a typed skill and evaluates unsafe/done questions”; the README states “The demo is synthetic orchestration, not a physics simulation or proof of grasp success.”
• JacobEGarcia/jev-robot-arm: “A live two-call policy simulation for carrying a block with a robot arm.” (description only; the README is empty).

Checked on 20 September 2026 (README and metadata read; experiments not reproduced). Measured Jev runs reported by their authors:

• Dimweaker/jev-libero: “Jev selects an intent, a contact/motion family, and an input, with each choice informing the next.”; LIBERO/MuJoCo with a “single-target Panda/OSC interface”; the README reports microwave “14” decisions / “111” environment steps / “$0.001249”, and top drawer “20” / “155” / “$0.001418”, under “One successful example from each bundled task:”; “Videos follow simulation time, with decision and physics-preview waiting omitted.”
• Foadsf/jev-for-engineers: “eight minimal working examples” for engineering decisions using “noul”, “choice” and “score”; “Sample inputs under data/ are entirely synthetic”; “Every example below has been executed against the live API”, including a BOM pair scored “1.91/2.00, confidence 0.86 → merge”; “That is a demonstration, not a calibration.”
• grmkris/robo-harness: “Decision runs (bun run jev) let an evaluation model or rules baseline pick bounded joint steps”; the README describes the “real SO-101 and both Pi cameras”; the acceptance record reports Jev choice “5/5, 14.2 s, $0.00028” and critic “17.2 s, $0.00028” for “Control smoke (gripper +4 %, wrist_flex +2°, back; upright neutral pose)”; “A fresh checkout defaults to mock hardware with synthetic cameras.”
• amazedsaint/jevduck: “Jev receives the group measurements together with recent physical outcomes.” and selects eligible group instructions; “MuJoCo WebAssembly computes the robot dynamics in the browser; the original ONNX policies control the articulated joints.”; live split/regroup/split checks report “approximately 0.07 m, 0.10 m, and 0.07 m respectively”; “No controlled comparison yet shows that Jev outperforms a deterministic supervisor.”
• GY19A/jev-stage: “The model returns a choice and a confidence number” and “The answer maps straight to a clip”; a browser “Three.js scene, VRM loader”; live-page example rows report “167 ms” through “305 ms”; “typing a message requires a key and a separately configured trusted proxy; a key alone is not enough.”
• atarikcaliskan/jevball: “Jev only picks among typed, pre-computed candidates and returns probabilities.”; “a football match in a 3D stadium”; a live sample reports “70 calls, 0 errors, 0 invalid answers, 366 ms average latency, ≈1,700 billed input tokens per call, $0.0051 total”; “These are short samples, not a benchmark: rate-limit behaviour over a full match and decision quality have not been studied in depth.” Source-available under “PolyForm Noncommercial License 1.0.0”.
• kavehmz/typesafe-playground: “Jev chooses lane and target speed for a car on a two-way road.”; “Jev receives structured simulated sensor observations rather than camera images.”; the driving verification record states “73 bounded real Jev requests were made for this update.” for its numeric-speed update; “Results apply to their recorded versions, not every later change or random seed.”
• robokrunch/jev-physical-ai: fleet-incident triage asks “3 simultaneous judgments”, “escalate to human (yes/no), owning team (choice), urgency (score 0-2)”; “Incidents are simulated from templates.”; the results table prints “300 / 300” successful decisions, “274 / 300 (91.3%)” team-label agreement, p50 “0.527 s”, p95 “0.813 s” and “$0.00737” total spend; “No real robot hardware, no edge NPU, no long soak test, no probability-calibration study.”

Integrations without a documented live Jev run:

• FBddcz/embodied-jev: a workbench for selecting operation phases and candidate actions, “模型负责在给定选项中做选择” (the model chooses from supplied options); “MuJoCo + Franka Panda” simulation with structured state; no measured run reported for Jev; “TypeSafe Jev / Claude 当前仍只有模拟响应测试，真实结果待补充。” (Jev and Claude have only simulated-response tests; real results remain to be added).
• rokbenko/quackd: an optional Jev stepper “scores a fixed set of options against a state and returns which one with a probability for each” ahead of a language-model pilot; tests use mock/simulated bodies, while the physical arm video’s pilot is “OpenAI’s gpt-6-astra”; no measured run reported; “never run against TypeSafe’s API and never on hardware” and “Those are estimates, not measurements”.

Tooling around Jev (agent infrastructure rather than a robot, simulator or 3D case; submitted by its maintainer in issue #1):

• BillionsBobby/JevRouter: “Models, subagents, skills, MCP tools, CLIs and plugins become one candidate set”; “Jev answers one typed Choice question, JevRouter enforces availability, permissions, risk and confirmation around it.” Its README reports a first-5 tool-call prediction test on 10 Toolathlon tasks with typesafe/jev-1.13-20260917 against DeepSeek V4.1 Flash: position-wise hits 38% (Jev serial), 44% (Jev decompose + thread) and 24% (DeepSeek), latency per task 1.58 s, 10.6 s and 8.65 s, cost per 10 tasks $0.0058, $0.0055 and about $0.0407; the README states “This experiment measures ordered routing decisions, not end-to-end task completion” and that “Provider performance and accuracy claims remain provider claims”. MIT license; README read on 2026-09-20.

Vendor code: typesafe-ai/typesafe-sdk-python, typesafe-ai/typesafe-sdk-js, typesafe-ai/skills and typesafe-ai/system-one-adapter-python (“Drop-in TypeSafeClient replacement backed by LLM APIs”).

Directories and coverage

• jevable.com: “An independent, curated collection of projects built with Jev”, run by Nikunj (@nikunj); it indexes X posts by their status ID, and its Robotics and Creative tools categories list several of the posts above.
• systemonemodels.org: a one-person site by Tim (timmyships.com) that states it “is not affiliated with TypeSafe AI or any model vendor”. Its real-time control page is worth reading before wiring Jev to a robot: “Hard real-time control is out of scope entirely. A loop that must hold a deadline every cycle cannot depend on a network request, whatever the median latency is.”
• RobotWorld: mirror of the MuJoCo comparison post with a one-line summary of the thread.

• Other lists: yibie/awesome-jev, cobanov/awesome-jev, AnotiaWang/awesome-jev, hellogumbo/awesome-jev, v-modal/awesome-jev-tools.

• TypeSafe Jev on LiteLLM: the article dated 20 September 2026 announces “v1.103.0-rc”; “LiteLLM proxies that endpoint with logging and cost tracking.” “Clients only need a LiteLLM virtual key.”
• Using TypeSafe’s Jev for evals (Langfuse): the article dated 18 September 2026 describes scoring stored traces: “you can pull observations via the API, determine a score with Jev, and write the result back as a score.” It also states “It gives you no reasoning back.”
• Videos (coverage, not cases): JEV Breakdown: The First AI Model Built For Code, Rob Shocks, 2026-09-16, a playground walkthrough of “Choice, Score, Noul, and confidence”; Jev - The Ultimate Classification Model?, Sam Witteveen, 2026-09-18, an overview for “a variety of different classification tasks”.

About the archived media

Video links open the file from this repository’s GitHub Pages site (https://frank-zy-dou.github.io/awesome-jev/), which serves them as playable MP4; the same files sit under assets/videos in the repository tree. The videos are re-encoded copies of the media attached to the linked posts (H.264, at most 540p); images are resized to at most 1280 px wide. Nothing is cut or edited. Files are named by case id, project and author, for example assets/videos/jev-002-so-101-ball-to-bowl-manipulation-daniiarabdiev.mp4. Authors who want a file removed can open an issue.

Contributing

Open a pull request that adds a row to the matching table with the original post URL, the author, the date, one or two sentences that stick to what the post says, the setup the post names, and an archived copy of the media under assets/. Reposts go on the original case’s row. Numbers need a link to the page where the number appears, and whether the run is simulated or physical must be visible in the video or stated in the post.