Jev + Deterministic Code = Mundane Work Automation

TypeSafe announced its first model, Jev. After getting off the waitlist and playing with it for a few days, I've become intrigued and excited about the future of (mundane) work automation.

My intuition is that Jev will unlock a lot of task automation built around deterministic blocks, rather than agents thinking their way through every step. And determinism brings the confidence and safety that could make a much larger class of work practical to automate.

Enterprises don't like magic

One of my biggest insights from my Applied AI days is that enterprise folks don’t really like blackbox, magical AI.

For a combination of audit, compliance, and liability reasons, well-defined, human-reviewed boxes often make a lot more sense, while keeping the AI layer thin, with guardrails and human-in-the-loop checks. Mistral shipped a great product to orchestrate such semi-deterministic workflows that I had the pleasure of contributing to.

While to prove a math theorem or write code from a human prompt you absolutely need "blackbox" AI with strong reasoning to accomplish the task, that's not the case for a large chunk of knowledge work. Invoice processing, customer support tickets, and many other tasks don't require advanced reasoning to resolve. You don't need Fable for everything.

Jev could make deterministic workflows practical at scale

Jev is an insanely cheap, fast classifier with confidence built in (my simplified definition).

This is gold if you want to build workflows with dozens of branches while keeping as much of the system deterministic as possible.

Each Jev call routes execution to the right deterministic block. The number of calls almost doesn't matter: it's still cheap, and you don't pay much of a latency penalty because the model is super fast.

But that's not the only benefit: each workflow run results in a really nice and easy-to-understand trace. Every branch is explicit, with a clear reason why the model chose that route (confidence included). And if at any point Jev returns low confidence, stop and ask a human to review.

I'm sure there are a lot of organizations that would love this model!

From an engineering perspective, this could also change how you automate tasks. Each step of the process is deterministic, while Jev decides which step to run next. If a step doesn't exist, stop, ask an agent to push a PR that handles the edge case, merge it, and continue. Over time, more and more edge cases become deterministic code.

A software factory for automating work. This could probably be a startup idea.

Open questions that matter

Confidence calibration! Can I tune confidence based on my historical data, and if yes, how hard is it? Does Jev know knowledge-work jargon, like wrong-way risk? Can I run it inside a VPC or on-prem? When is it stable enough to use in prod?

The above are boring questions, but I suspect the answers to them will dictate when orgs are able to battle-test Jev on real use cases.

Overall: exciting times ahead!

I'm hooked! We got a new model that could potentially be a missing piece for automating large chunks of boring, mundane work. While agents humans work on more complicated and interesting things.