Jev by TypeSafe AI: The Complete Developer Guide

Jev is a model from TypeSafe AI that returns typed decisions with probabilities instead of text. You send data plus questions with fixed answer options, and get back one answer per question in roughly 70-500 ms, at $0.042 per million input tokens with output free. It's great for routing, classification, scoring, guardrails, and LLM-as-judge work. It can't write, can't do math, has no vision, and isn't open weights. Treat it as a smart if statement, test it on your own data, and ignore the hype posts.

In the past ten days, Jev has taken over r/LocalLLaMA, r/LLMDevs, r/AI_Agents, and half of dev Twitter. Some call it the biggest thing since ChatGPT. Others call it "just a classifier" with a $40M marketing budget. Both camps are partly right, and the useful answer sits in the details.

This guide covers what Jev is, how the API works, real code, pricing, where it breaks, what people are building, and straight answers to the questions that keep coming up on Reddit.

Find full video here:

What Jev actually is

Jev is a model that makes decisions and does not write text. You send it some data (the "state") plus a set of typed questions, and it sends back one answer per question with probabilities attached.

It comes from TypeSafe AI, a San Francisco lab that came out of stealth on September 15, 2026 with $40M in seed funding led by DCVC. The founder is Diogo Almeida, who worked at OpenAI on RLHF and InstructGPT. Jev is their first public model, and TypeSafe calls it a "System One model."

The best mental model is a smart if statement. Normal code branches on things it can compute:

if (order.total > 100) applyDiscount(order);

That falls apart when the condition needs judgment. Is this ticket angry? Is this email about billing? Which of these 40 buttons continues checkout? Before Jev you had three options: write brittle rules, train a custom classifier with labeled data, or ask an LLM for JSON and hope. Jev takes questions you define at runtime like an LLM, but returns a constrained probability distribution like a classifier.

The name has two references. "Jev" comes from William Stanley Jevons, whose paradox says that cheaper resources lead to more consumption. "System One" comes from Daniel Kahneman's fast, intuitive System 1 thinking, as opposed to slow, deliberate System 2 reasoning. TypeSafe's bet is simple: make an AI decision cost a tiny fraction of a cent and you'll put decisions in places you'd never call an LLM.

If you want the ELI5 version for your non-dev friends: Jev is a very fast multiple-choice test taker. You hand it some information and a few questions with fixed answer options, and it circles one answer per question and tells you how sure it is. It can't write an essay, but it can take thousands of these tests per second for pennies.

How it works under the hood

TypeSafe hasn't published much about internals, so be careful with anyone claiming to know the exact architecture. What's public from the launch post: a new model architecture, a parallel sampler, and a training method called Reinforcement Learning for Calibrated Decisions (RLCD). Jev is transformer-based but not an LLM. No weights, parameter count, or architecture paper have been released.

The key difference from an LLM with structured outputs is how the answer gets produced. An LLM generates {"category": "billing"} token by token, and a schema only constrains that process. Generation can still fail, stop early, or drift. Jev evaluates every question independently and in parallel against the same state, and outputs a probability distribution over the options you defined. A successful response can never contain a value outside your schema.

RLCD is the training side. TypeSafe argues that RLHF tuned models for human preference, which produced good chat but also overconfidence and mode dropping. RLCD instead aims for probabilities that match outcomes: across many predictions, answers given 90% probability should be right about 90% of the time. That calibration claim is the most important one, and it's also the least independently tested so far.

The "it's just Qwen plus logits" theory from r/LocalLLaMA deserves a fair hearing. Yes, you can approximate the behavior by taking an open LLM, doing a single forward pass, and reading the probabilities over a fixed answer set. People have done this for years, and several "Jev in 25 lines of Python" posts show it. Whether Jev does something meaningfully better depends on RLCD and the parallel sampler, and without weights nobody outside TypeSafe can verify that. Test it on your data instead of arguing about it.

The API: three primitives, one endpoint

Everything goes through one endpoint:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer <API_KEY>
Content-Type: application/json

The body carries model, state, and a map of questions. There are three question types:

Type	What it asks	What comes back
noul	Is this true?	noul: probability from 0 to 1
choice	Which of these options?	choice, probabilities, confidence
score	Where on this ordered scale?	score, legend, probabilities, confidence

"Noul" is TypeSafe's name for a yes/no question. The Vercel AI SDK calls the same thing boolean.

Here is a raw request for support ticket triage:

curl -s https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": {
      "ticket": "Our webhook stopped firing after the update. We are losing orders. Please fix today."
    },
    "questions": {
      "team": {
        "type": "choice",
        "instructions": "Which team should handle `ticket`?",
        "criteria": {
          "billing": "Charges, invoices, refunds",
          "engineering": "Bugs, outages, integrations",
          "sales": "Pricing, upgrades, new accounts",
          "other": "Anything else"
        }
      },
      "severity": {
        "type": "score",
        "instructions": "How severe is the problem in `ticket`?",
        "criteria": [
          "Cosmetic, nothing is blocked",
          "Feature broken but a workaround exists",
          "Blocking, customer is losing money or data"
        ]
      },
      "is_urgent": {
        "type": "noul",
        "instructions": "Does `ticket` ask for action today?"
      }
    }
  }'

The response always has the same shape: an answers object keyed by your question IDs, the versioned model that answered, and usage with token counts. A Choice answer looks like this:

{
  "type": "choice",
  "choice": "engineering",
  "probabilities": { "billing": 0.02, "engineering": 0.95, "sales": 0.0, "other": 0.03 },
  "confidence": 0.91
}

A Score returns the probability-weighted mean of the level indexes. A 1.7 on the severity scale above means "mostly blocking, some weight on workaround exists."

A few things trip people up:

• The question ID is not sent to the model. team means nothing to Jev, so the full question must live in instructions.
• Use backticks around field paths like `ticket` or `order.items[0]` so the model knows which part of the state you mean.
• Always add an other option to a Choice when your list might not cover every input. Jev has to pick something.

Python SDK

pip install typesafe-sdk   # Python 3.10+

from typesafe_sdk import Choice, Noul, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY

resp = client.system_one(
    state={"ticket": ticket_text},
    questions={
        "team": Choice(
            instructions="Which team should handle `ticket`?",
            criteria={
                "billing": "Charges, invoices, refunds",
                "engineering": "Bugs, outages, integrations",
                "other": None,
            },
        ),
        "is_urgent": Noul(instructions="Does `ticket` ask for action today?"),
    },
)

team = resp.answers["team"]
if team.confidence < 0.5:
    send_to_human(ticket_text)
elif team.choice == "engineering" and resp.answers["is_urgent"].noul > 0.8:
    page_oncall(ticket_text)

There's also an AsyncTypeSafeClient with configurable retries.

JavaScript / TypeScript SDK

npm install @typesafe-ai/sdk   # Node 20+

import { choice, noul, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();

const { answers } = await client.systemOne({
  state: { ticket },
  questions: {
    team: choice("Which team should handle `ticket`?", {
      billing: "Charges, invoices, refunds",
      engineering: "Bugs, outages, integrations",
      other: null,
    }),
    is_urgent: noul("Does `ticket` ask for action today?"),
  },
});

// answers.team.choice is typed as "billing" | "engineering" | "other"

The TypeScript SDK infers answer types from your question definitions, so you get autocomplete and exhaustive switch checks for free. Keep calls on the server, since the SDK blocks browser use to protect your API key.

Other ways to call it

• Vercel AI Gateway: available as typesafe-ai/jev at the same price, no waitlist. AI SDK 7 has experimental_evaluate for this kind of model. Note that TypeSafe's confidence lives in result.providerMetadata.typesafe.confidence on that path.
• LangChain: exposed through TypeSafeClassifier.
• Cloudflare Workers AI: users report it listed as typesafe/jev.

Limits and errors

Limit	Value
State + all questions	~64,000 tokens
State + longest single question	~32,000 tokens
Choice options	up to 255
Score levels	2 to 10
Input	text only (string, JSON object, or JSON array)
Rate limits (early access)	250,000 tokens/sec, 1,200 requests/min

Errors: 401 bad key, 422 validation failure (the response names the field), 429 rate limited, 529 overloaded. Retry the last two with exponential backoff; the SDKs do this for you.

The current model is jev-1.13.0, and jev-latest points at the stable release. Log the versioned model ID from every response, and pin it once you've tuned thresholds against it.

Confidence, fan-out, and the patterns that matter

The probabilities are the real product. Every Choice and Score answer carries a confidence from 0 to 1, computed from the shape of the distribution. If one option dominates, confidence is high. If probability is spread across options, it's low. An answer can win at 0.84 and still have confidence around 0.6 because a second option holds meaningful weight.

That gives you a clean three-band pattern:

const { team } = answers;

if (team.confidence >= 0.9) {
  autoRoute(team.choice);          // act
} else if (team.confidence >= 0.5) {
  routeWithReview(team.choice);    // act, but flag for review
} else {
  sendToHuman();                   // don't trust it
}

Set thresholds by the cost of being wrong. Labeling a dashboard event can run at 0.5. Deleting a file should need 0.9 and probably a human anyway. Your risk tolerance lives in plain numbers in your code, which is far easier to review than a prompt.

Speculative fan-out. With LLMs you ask one question, then decide the next. With Jev, questions run in parallel and each extra one only costs its own tokens, so ask everything you might need in one call and let code decide which answers to use. In one TypeSafe cookbook, 13 questions in a single call were 12.2x cheaper and 10x faster than 13 sequential calls. Most of that saving comes from sending a large state once, so it matters most with big inputs.

Composite scoring. When a judgment depends on several factors, ask one Score per factor and combine them in code:

// normalize each score to 0..1 by dividing by (number of levels - 1)
const norm = (ans, levels) => ans.score / (levels - 1);

const priority =
  0.6 * norm(answers.severity, 3) +
  0.3 * norm(answers.frustration, 3) +
  0.1 * norm(answers.report_quality, 4);

If rankings feel off, change a coefficient and rerun. No prompt rewriting.

Routing. This is where most real savings show up. Put Jev in front of your stack and let it decide whether a request needs a database lookup, a cheap model, an expensive model, or a person. The order-status lookup never touches an LLM, and only the hard cases reach your frontier model. The same idea works as a model router inside an agent.

Using coding agents to integrate it. Install TypeSafe's agent skill first, because agents trained on LLM APIs tend to ask one question per call and invent request fields.

# Claude Code
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

# Cursor, Codex, others
npx skills add typesafe-ai/skills --skill typesafe-ai

Pricing and speed, with the fine print

Jev costs $0.042 per million input tokens (TypeSafe markets it as $42 per billion), and output tokens are free because there's almost nothing to meter. For comparison, TypeSafe quotes typical LLM input prices at $0.20 to $10 per million. A 300-token support ticket costs about a hundredth of a cent. TypeSafe reports 70-500 ms end-to-end, measured from the US West Coast, so add your own network latency if you're elsewhere.

The famous "193.6x faster, 444.6x cheaper" numbers need context. They come from TypeSafe's own workflow evals, where the reference answers were generated by frontier models and the workflows were written by TypeSafe's team. TypeSafe itself says these gains sit at the high end of real use, and that it can't prove the price isn't subsidized.

Independent checks are more modest but still strong:

• An r/accelerate test on multiple-choice benchmarks found Jev roughly Terra-tier on System 1 tasks at about 18x lower cost.
• Bryo AI's CTO found Gemini slightly more accurate for email triage, but 10-20x more expensive.
• One r/LocalLLaMA user got 94.6% with a model trained on their own data versus 68.1% for Jev over the API.

That's the realistic picture. Jev is a strong general-purpose default, and a narrow model trained on your data can still beat it.

For your own bill, the math is simple:

savings = (share of AI spend on decisions) x (how much cheaper Jev is on those calls)

If 60% of your spend is classification, routing, scoring, and verification, you might cut the bill by more than half. If it's 10%, you'll save at most 10%. Include retries, human review, and any LLM steps before or after Jev in the calculation.

Where Jev breaks

TypeSafe is fairly honest about limits and publishes a "jaggedness" page per model version. These are the failure modes that matter in production.

It can't do math. Counting, arithmetic, date comparisons, and hex color distances are unreliable. Do those in code and pass in the result. To count items that match a meaning, ask one Noul per item and sum in code:

const questions = Object.fromEntries(
  items.map((_, i) => [`item_${i}`, noul(`Is \`items[${i}]\` a fruit?`)])
);
const { answers } = await client.systemOne({ state: { items }, questions });
const count = items.filter((_, i) => answers[`item_${i}`].noul > 0.5).length;

It reads you literally. Scoping words, negations, and implied conditions get taken at face value. If you catch yourself explaining what you "really meant" after a wrong answer, that explanation belongs in the instruction.

Score is not a measurement. A 1.4 doesn't mean "40% of the way between levels." Use scores for thresholds and ranking only. Describe situations in your criteria ("blocking, no workaround exists") instead of degrees ("very severe"), or the model spreads probability across levels.

Context rot. Accuracy drops as the state fills with irrelevant content. Filter in code first, or ask a Noul per chunk ("is this relevant?") and drop the rest.

Prompt injection. State is treated as data, but adversarial text can still shift answers. Test with hostile inputs before exposing it publicly.

"Zero hallucinations" is a narrow claim. It means Jev can't return an option you didn't define. It can still pick the wrong one. The 0% figure is a structural guarantee about the output shape, not an accuracy number.

No vision, no writing. Images, audio, and video need converting to text first. People have forced it to "chat" by picking one character at a time, but it's slow and bad at it. The working rule: with Jev you pick a card from the deck, you don't ask it to name one. If your instinct is "extract X," rephrase it as "here are the candidates for X, which one is it?"

It's closed. Hosted API only, early access behind a waitlist, no weights and no self-hosting option.

What people are building with it

The community moved fast. shipwithjev.com, an independent catalog, already lists hundreds of builds. Some highlights with real numbers:

Browser and phone agents. Browser Use's jev-ultrafast ran a Zurich to London Google Flights search in 7.1 seconds. A planner LLM sets the goal, and Jev picks the next element to click as a Choice over the page's interactive elements. Droidrun's mobile-jev drove Uber on a real Android phone.

browser-use / jev-ultrafast

Fastest and cheapest web agent

Jev Ultrafast ⚡

Important

The Browser Use Cloud waitlist is open. Get early access to ultrafast browser agents in the cloud Join the waitlist →

A browser agent with a dynamic, indexed action space.

Give it one goal. TypeSafe's Jev picks an operation and an element. A small LLM writes text only when the operation is TYPE_TEXT.

Zürich → London on Google Flights in 7.1 seconds. One natural-language goal, actual text generation, and loading waits included.

Watch the MP4 · Measurements · Read the loop

The action space

Every observation produces a new element table:

[1] button    Change ticket type · Round trip
[2] combobox  Where from?        · San Francisco
[3] combobox  Where to?          · empty
[4] textbox   Departure          · empty
...

The operations are CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED. Only supported operations and targets are offered.

…

View on GitHub

Coding agent guardrails. jev-guard rates each tool call as deny, ask, or allow. Vercel CEO Guillermo Rauch reported Jev up to 18x faster at p95 than GPT Luna for command safety checks, and more accurate. Others use it for Pi's auto mode, instant context compaction (score each old tool call and drop the irrelevant ones), and as a "subconscious" filter that handles small checks before the main model sees anything.

leepokai / jev-guard

Auto mode for every coding agent, built on Jev: risk-scores every tool call with session context (deny / ask / allow), flags prompt injection in results, checks skills and plugins. Claude Code, Codex, Copilot, Gemini, Cursor, pi, OpenCode, ACP.

jev-guard

A security hook for coding agents, powered by Jev.

Auto mode, for every coding agent

Claude Code's auto mode is described as: "A separate classifier model reviews actions before they run, blocking anything that escalates beyond your request, targets unrecognized infrastructure, or appears driven by hostile content Claude read." That is exactly the job jev-guard does — as three typed questions to Jev (risk, user_requested, from_untrusted) instead of a proprietary classifier — and it does it for Codex, Copilot, Gemini, Cursor, pi, OpenCode and ACP editors too, with the same policy and the same session memory everywhere. If you want auto mode outside Claude Code, or a second opinion inside it, this is the build.

Why Jev: price and speed, with sources

Figure	Source
Price	$0.042 per 1M input tokens, $0 output — a typical jev-guard call is ~1k tokens, so ≈ $0.00004 per

…

View on GitHub

Production usage. Metaview, a recruiting platform, says it shipped Jev into every agent on its platform over a weekend, and candidate searches went from minutes to seconds at the same accuracy and lower cost.

Bulk labeling. A teardown of 724 live ads from 37 brands took about 40 seconds and nine cents. Resume screening, email triage, listing classification, and feature engineering for classical ML models all fit the same "label every row" shape.

Search and databases. JevQL and pg-jev let you add plain-language filters to Postgres queries, like WHERE jev(meetings, 'could have been an email'). jevsearch re-ranks keyword hits by intent with no vector database. For memory retrieval in agents, the pattern is similar: pull a larger candidate set with vector search, then ask Jev per item whether it's relevant. Results in r/Rag were mixed, so expect precision gains, not magic.

kylemclaren / jevql

Semantic SQL for Postgres, powered by Jev

jevQL

Semantic SQL for vanilla PostgreSQL. One extra family of functions, jev(), works in any query, from the CLI, from a shared HTTP and MCP node, or from the Go, TypeScript and Python SDKs.

SELECT name, city, jev_prob(people, 'could work from home') AS p
FROM people
WHERE jev(people, 'could work from home')
  AND country = 'PT'
ORDER BY p DESC
LIMIT 20;

The database only ever sees ordinary SQL. jev_* calls are evaluated by the CLI using TypeSafe's System One model (Jev). No CREATE EXTENSION, no superuser, no wire-protocol proxy.

Install

Homebrew (macOS and Linux):

brew install kylemclaren/tap/jevql

Prebuilt binaries for macOS and Linux (arm64 and amd64) are attached to each GitHub release as jevql_<version>_<os>_<arch>.tar.gz with a checksums.txt.

From source, with Go 1.23+ and a C compiler (libpg_query is bundled via pg_query_go and needs CGO):

CGO_ENABLED=1

…

View on GitHub

LLM-as-judge replacement. People use Jev to grade agent traces against rubrics, check whether a cited source supports a claim, and verify RAG answers. One r/Rag benchmark found it tied on accuracy while being 187x cheaper, but it let through 23% of unsupported claims. Good as a first pass, risky as the only check.

Real-time apps and games. Doom at about 10 decisions per second, Pac-Man, StarCraft, Minecraft, NPC combat decisions, live tone scoring while you type, a debate "BS meter," and Home Assistant control through HA-Jev. Voice agents are a natural fit too, since turn-level decisions like intent routing, escalation, and "did the caller confirm?" need answers in well under a second.

Security and moderation. Jailbreak and PII detectors under 300 ms, anti-phishing checks, secret detection, spam and auto-reply detection in the Laravel AI SDK, and moderation against a site's own rules.

Two warnings. The trading bot threads (including one that reportedly lost $31,680 overnight) prove that fast decisions aren't good decisions. Jev doesn't understand markets any better than an LLM. And most of these are first-week demos, not production case studies. Every cost and latency figure above is self-reported by the builder.

Every Reddit question, answered

Isn't it just a classifier?
Mostly yes, and that's the point. Normal classifiers need labeled data and training per task, while Jev takes new labels at runtime. "A zero-shot classifier with calibrated probabilities behind a fast API" is an accurate description. Whether that deserves the hype depends on how many of your LLM calls are secretly classification. The r/AI_Agents hot take nailed it: we've been using LLMs as very expensive if/else statements.

Why not just use normal automation or JSON parsing?
If a rule can decide correctly, use the rule. It's free and never wrong. Jev is for conditions a rule can't express, like "is this customer about to churn" or "does this message sound like a scam." Parsing tells you what fields exist. Jev tells you what the text means.

Jev wasn't first. Same work existed months earlier.
Correct. Using LLM logits for classification is old, and several researchers posted earlier open work. TypeSafe never claimed to invent the concept. Its claim is a new training method and a production-grade API, which is more of a product achievement than a research one.

They raised $40M and an open clone matched the API in 3 days. Where's the moat?
Copying the API shape is easy, since it's just state in and probabilities out. Copying the quality of the probabilities is the hard part. If RLCD really produces better-calibrated answers than a logit-grabbing hack, that's the moat. If it doesn't, the Christensen-disruption crowd is right and this becomes a commodity fast. Nobody outside TypeSafe has proven which is true yet.

How is RLCD even RL if the outputs are differentiable?
Fair question, and TypeSafe hasn't published a paper to settle it. Choice, Score, and Noul outputs could be trained with plain supervised loss if you had perfect labels. The RL framing likely comes from rewarding calibration against outcomes rather than matching fixed labels. Until details are public, treat "RL" as TypeSafe's description, not a verified method.

Can I run it locally or self-host it?
Not Jev itself. Open alternatives appeared within days: Laya (an open-weights System One model some users report beating Jev on speed), OpenJev, Nokia's AnyJev (a training-free layer that turns open LLMs into calibrated decision models), and Contrastive-LM's CLM-8B. If data residency or cost at huge scale matters, benchmark these on your task. As for "Laya came first, why is everyone talking about Jev?", distribution and polish usually beat being first.

Is it a scam?
No. The API works, pricing checks out in independent tests, and the founder's track record is real. The "scam" posts mostly point to a single bias example or to aggressive marketing.

Jev said Taiwan isn't a country / shows sexist or racist tendencies.
Jev always picks one of your options, so it gives an answer on sensitive questions where an LLM might hedge or refuse. That makes underlying biases more visible. It doesn't prove it's a Chinese model or uniquely biased, but it does mean you must test hiring, moderation, lending, and anything involving people for fairness before shipping.

Why is Reddit flooded with Jev posts?
Part genuine excitement, part low-effort SEO spam (the "use Jev for FREE" posts). The r/LocalLLaMA mod request got 1.2K upvotes for a reason. Trust posts with code and numbers.

The demos are misleading (Tesla FSD in an hour, car wash question).
Partly true. The "FSD" demo fed Jev clean simulated data instead of camera input, which is the hard part of self-driving. Game and driving demos show latency, not real-world readiness. The car wash cost comparison ($6.86 for Jev vs $57.84 for DeepSeek) shows a real gap on that task, but one benchmark isn't your workload.

Can I use it with OpenAI, ChatGPT, Codex, or Claude?
Alongside them, not as a replacement. Jev decides, the LLM writes. Common setups use Jev to route between models, gate tool calls, or filter work before an expensive agent runs.

Is it good for coding?
It can't write code. It's useful around coding agents: command safety checks, "is the task done?" checks, picking which files matter, semantic linting, and routing tasks to the right model.

People used it to generate pixel art and game levels. I thought it can't generate?
It can't on its own. Those builds use an LLM or code to propose options, and Jev picks between them fast and repeatedly. The generation comes from the loop, not the model.

Is it good for roleplay?
As a helper, maybe. It can decide mood, which character speaks next, or whether a reply stays in character, while a writing model produces the text.

Jev controlling a Mac in real time: better than Astra or Fable?
Faster, not smarter. Computer control is mostly a string of small choices (which button, which menu), which suits Jev. It needs a text view of the screen like an accessibility tree, since it has no vision. For multi-step planning, reasoning models still lead, so the common pattern is LLM plans, Jev clicks.

Can Jev detect AI-written posts?
It can score text against criteria you write, but it has the same problem as GPTZero and other detectors: there are no reliable signals for AI writing. Don't auto-reject posts on its score alone.

Will 400x cheaper inference unlock ad-supported AI apps?
For decision-heavy features, the cost per user drops low enough that ads could cover it. But most consumer AI value is still generated text, which Jev can't produce.

How do I get access? Is there a free tier?
Join the waitlist at typesafe.ai (people report getting in within a day or two), or use the Vercel AI Gateway at the same price with no waitlist. There's no known free tier beyond that, so be suspicious of "free Jev" posts.

---

Where to start

Pick one boring decision your code handles with a fragile regex or a costly LLM call. Replace it with one Noul or one Choice. Run it in shadow mode next to your current logic for a week, log the confidence, compare against real outcomes, and only then let it act on the low-risk path. That's how a smart if statement should be adopted: one branch at a time.

Useful links: Launch post · Docs · Agent skills · Community builds

What are you using Jev for, or what's stopping you? Drop it in the comments.