Cranking out Good Code 
On Monday night I spoke at AIMUG in Austin (the community that started as the Austin LangChain user group). My first talk there was in July 2025, when I asked an agent to add “philosophically deep insights” to my website’s home page. It declared that Austin LangChain was “the evolutionary leap that humanity has been waiting for since the dawn of consciousness itself” and then added a puppy mascot nobody asked for. That page is still live.
A year and a half later, the agents got a lot better. The puppy stayed.
This time I covered two things I think are real game changers: Jev, a decision model that answers with calibrated probabilities instead of text, and personal agents like Grok Bot, Hermes, and OpenClaw. Together they’re knocking down the barriers that keep LLMs from reaching everyone: cost, speed, convenience, and accuracy.
Jev is the one people wanted to talk about afterward, so let’s start there.
Jev: a model that doesn’t write text
Jev comes from a company called TypeSafe, and the key thing to understand is that Jev is not an LLM. It doesn’t generate prose. You give it:
- a state: a ticket, an email, a JSON blob, a document
- several questions at once: yes/no, multiple choice, or a score
And it returns probabilities over the possible answers, all in one fast pass.
State + questions in, probabilities out. No prose.
Why “calibrated” is the whole point
When an LLM tells you “I’m 90% sure,” that number is just more generated text. It doesn’t have to match anything inside the model, and RLHF tends to push models to sound confident even when they’re wrong.
Jev is trained with RLCD (Reinforcement Learning for Calibrated Decisions). As the IBM explainer video puts it: “When we say that there is an 80% probability… that 80% probability is going to be correct about 80% of the time. That’s calibration.”
That sounds like a small thing. It isn’t. A number you can trust is a number you can build on.
Thresholds: confidence becomes a control surface
Once the probabilities mean something, you can route work with simple rules:
- Above 0.9: automate it.
- Between 0.1 and 0.9: send it to a human.
- Below 0.1: ignore it.
And when a mistake is expensive, you just raise the bar.
Calibrated confidence turns into routing rules and guardrails.
Guardrails and agents
Jev also works as a guardrail. Check for jailbreak attempts before a prompt ever reaches your LLM, or check the LLM’s output before it reaches the user. The pattern I like best combines the two: Jev routes, the LLM drafts, Jev checks. For agents, that means you can route, defer to a human, or gate an action with a real threshold instead of a vibe.
System 1, not System 2
TypeSafe calls Jev a “System 1” model, borrowing Daniel Kahneman’s terms from Thinking, Fast and Slow. System 1 is the quick judgment call: what’s 2×2? You just know. System 2 is the slow, deliberate work, like 17×24, which is where LLMs and reasoning models live. Jev is built for the first kind. It’s not good at math or counting, and it isn’t trying to be.
Jev handles the fast judgment calls. LLMs handle the slow, deliberate work.
Named for Jevons Paradox
The name doesn’t come from Kahneman. It comes from William Stanley Jevons, who noticed in 1865 that as steam engines got more efficient, Britain burned more coal, not less. Cheaper and faster means you use it everywhere.
Make something efficient enough and usage explodes.
That’s the real reason I think Jev matters. In the video’s words: “When a judgment call is super fast and super cheap like with Jev, well it can go into places where an LLM would be too slow or too expensive today, like in every row of a database or on every line of a log file.” Cost and speed stop being the reason you don’t put AI somewhere.
To be clear, this is what I think it unlocks. I’m still prototyping with it, not running it in production.
Living with personal agents
The second half of the talk was a lived-with review. I’ve run OpenClaw since it launched and Hermes on my M1 Mac, and now Grok Bot. Everyone is building the same thing:
The real differences: who hosts it, who picks the model, and who holds your data.
Prices change constantly; these were as of the talk.
My takeaways:
- Self-hosting is bring-your-own-everything. Your data and model, probably cheaper, but you run and secure the machine.
- Grok Bot is easy and generous, but you trust the vendor with your data.
- A VM beats my MacBook. If an agent goes sideways, I’d rather it be on a cloud computer than my home network.
How I actually use Grok Bot
- Calendar + email (#1). It pulls an event out of an email, enriches it, and adds it only if it doesn’t conflict.
- This day in history, with a generated image, ported from my original OpenClaw agent.
- My Obsidian vault: projects, a personal CRM, and blog drafts (including this one).
- Strava. It makes it easier to upload pictures of my runs and see who else is out running, without opening the app.
- A coaching bot for fitness.
My favorite trick: the agent publishes little web pages to my own domain with here.now.
No build, no deploy. Minutes, not a pipeline.
What I learned from the other talks
- Semantic routers as defense in depth. The vLLM Semantic Router and NVIDIA Switchyard add a routing layer in front of your models, so safety doesn’t rest on one prompt or model.
- Shorter instructions can make agents better. A talk on the Harbor evals framework showed that trimming
agents.mdinstructions improved MCP tool use. - Spec-driven “coding factories,” close to how I work with task queues.
Try this week
- Start small: calendar + email + one routine.
- Publish something personal on your own domain.
- Match the platform to your trust and data needs.
The slides are here: share.fluckiger.org/aimug
Thank you, AIMUG. I learn something every single time I show up, and it’s a privilege to give a little back.