It's Not a System 1 Model If It Takes Ten Seconds
Fastino's GLiDE beats every open model on our reasoning benchmark, but not Jev: less accurate, five times slower, ten times the cost, and a confidence that barely tells right from wrong.
- Question
- Yes
- No
A question goes in. A verdict comes out, with a confidence we can check.
The OpenAI Decisions API Needs a Confidence You Can Trust
We've routed decisions on LLM confidence since 2023, and calibration is what we most hope OpenAI's new Decisions API gets right. The model underneath, GPT-6 Luna, isn't there yet: on 3,600 reasoning problems its 99% meant 68%, and by five inference steps it was at a coin flip.
Can Averaging Reduce Noise in an AI Decision Model?
We asked Jev the same question ten times in one request and expected ten identical answers. They split, four votes to six. Kahneman, Sibony and Sunstein call that kind of variation noise. Averaging the copies didn't make Jev more accurate, but it cut changed answers on a rerun by about a third.
- Reviewer says no
- Rule
- Passed by rule
A reviewer says no once, and we write down why. After that, the rule handles the same case without them.
Primus Is a Classifier Lab: Operationalizing Classifiers at Scale
A hosted decision model sat at 77 percent accuracy through 87 rounds of reviewer feedback, then one approved question took it to 87. Here is the loop that did it, every figure published, and the offer to run it on your judgment task.
Decision Models Are Not Calculators
Jev chose one in every ordering of a fair-die question; Kev leaned toward one, and Laya overwhelmingly chose six. Benford's Law remains a hypothesis.
The One-Word Test: How Jev and Laya Read Gender, Race and Age
Two thousand real bios per job, first names blanked, one pronoun swapped, both decision models asked twice. Laya's verdict moved on 8 to 18 bios in 100, Jev's on 1 to 4, almost always toward the stereotype. Here is the method, the jobs, the shortlist, and what names and ages do.
We Told the AI She Was a Woman. It Demoted Her
A new kind of AI, the decision model, makes instant decisions about people: who gets an interview, whose claim gets flagged. It's cheap and fast, and companies are adopting it without checking what it does. We checked. It quietly ranks women lawyers below men, and every company using it makes the same mistake.
Can You Fix It? Gating, Averaging and Fine-Tuning Against a Gendered Verdict
A decision model's verdict moves on "she". We put a gate on the learning loop that rejects any question whose answer moves with the pronoun. It kept out the obvious ones and still made a hiring shortlist worse, because a question can ignore the pronoun and read gender from the words. Here's what worked instead.
Jev vs Laya: Same Labels, Same Questions, One Variable
We ran two decision models, Jev and the open-weights Laya, through one harness where only the engine changes. Jev led by 4.7 points alone and 6.8 with our feedback layer, and then fine-tuning Laya on the same 140 labels beat both.
Fine-Tuning Jev: You Can't. Here's What Gets You the Same Effect
You can't fine-tune Jev, or any hosted decision model: TypeSafe serves the same weights to everyone. So we kept it frozen and adapted the questions and a small fitted head around it. On 140 labels, one new plain-English question bought 10 points of accuracy, and it finds the hidden pattern about a quarter of the time.
Distilling an Aligned Jev System into a Classifier You Own
A Jev decision model aligned with 140 human labels taught a 66M-parameter DistilBERT that scored 0.912 against the human label, two points above its teacher, at 5.6 to 15 ms an item. The accuracy is the least general part; the per-slice ship gate is the part to copy.
Can You Trust Jev's Confidence?
A decision model's confidence should mean something. Jev's does: higher really does mean more likely right. But on 8,801 labeled examples they ran overconfident, and how you phrase the request changes the pattern. Calibration fixes most of it.
Decision Models: Making Decisions Instead of Generating Text
Jev is a decision model: it turns a scorecard’s bounded questions into the model’s native output, making high-volume QA faster, cheaper, and easier to operate.
An agent skill for not sounding like an agent
"Sound less like AI" isn't a prompt problem. It's a tooling problem: give your copy-editing agent a deterministic slop detector, checked against your publication's own rules instead of a generic notion of "human." Limatus is what that looks like as a real, open-source tool.
Who actually swapped off premium models
Useful capability got cheaper. Here are named orgs that moved production traffic, what they swapped or routed to, and one checkable number each.
Inspected by Pudicus
Pudicus makes git hooks actually run, so agent swarms scan for secrets before they commit. Once a secret is in history, it's expensive to unwind.
Grok Bot Gave My Coding Agents a Boss
Grok Bot rapidly became the control room for my army of bots: filing bugs, dispatching parallel Cursor workers, rejecting weak work, and returning fixes for acceptance testing—with less help from me than I expected.
From pair programmer to executive
Coding agents became cheaper and better at long-running work at the same time. The next step is not another pair programmer. It is a software organization with reporting lines, review gates, and a human setting direction from above the day-to-day loop.
Bugonomics: The Flip Side of Cheap Coding
When breaking software gets as cheap as writing it, cheaper offense means more offense. The same price-performance curve that turned a $200 coding habit into a $20 one is turning million-dollar exploit chains into something approaching commodity.
The Content Paradox: Why Making AI Writing Easier Makes the Internet Worse
When you make content creation 100x cheaper, you don't get 100x better information—you get 100x more noise. The economic logic of Jevons Paradox explains why AI is drowning the internet in synthetic mediocrity.
Never Use Fast
Premium Fast mode is a latency product, and agent work is almost never latency-bound. Do not confuse the expensive priority lane with the cheaper Flash-style models that made fast synonymous with efficient.
Maximize Value, Not Intelligence
In 2023, we argued for using the dumbest model the problem will bear. That rule still works, but choosing one model isn't enough anymore. Route each job to the cheapest model that clears the bar, then measure the cost of work you actually accept.
The Year Coding Became a Commodity
Coding agents didn't just get better. Useful coding capability got dramatically cheaper at the same time agents learned to work for longer. Those two curves multiply, changing both what small teams can attempt and where human judgment matters most.
All Your Agents Are Belong To Us
You pointed the agent at an LLM API router, so it can read every tool call. An April 2026 measurement found cheap and free routers already rewriting commands and stealing credentials. The paper should have been titled All Your Agents Are Belong To Us.
The Simulation Told Them They Would Win
AI war-gaming and targeting tools compress tempo and produce confident projections—but when strategy is wrong, speed and sycophancy only widen the gap between tactical success and strategic failure.
The Turn Detection Trap: When 100% Accuracy is Wrong
We fine-tuned MobileBERT for turn detection and achieved 100% accuracy. Then we realized we hadn't solved turn detection at all—we had just built a very expensive punctuation detector.
AWS Lambda for AI/ML
Serverless isn't just for web apps anymore. Here's how we use the "Serverless AI Stack"—Lambda for orchestration, AgentCore for agents, and SageMaker Serverless for inference—to build production AI systems that scale to zero.
How to Make a Text Classifier Using an LLM
Classification-with-Confidence follows an LLM classifier from Yes-or-No token probabilities through calibration, routing, and task-specific fine-tuning.
Give an Agent a Tool
A demonstration of a fundamental paradigm shift in computer programming: from writing explicit code for every scenario to giving intelligent agents the right tools and letting them figure it out. This project shows how the same task that requires hundreds of lines of complex branching logic in traditional programming becomes simple and flexible with agentic AI. Through a real-world example of extracting contacts from varied CSV formats, we compare traditional approaches against agent-based data processing that handles unexpected formats without code changes, demonstrating the 'give an agent a tool' paradigm in action. View the project on GitHub.
Project Plan Files: A Simple Technique for AI-Assisted Development
Keep your AI pair programming sessions focused and efficient with a simple technique: maintaining a project-plan.md file in your repository. Here's how this approach has transformed our development workflow.
Rethinking AI Hallucination: The Unsung Hero of LLM Problem-Solving
AI hallucinations are often seen as a critical flaw, but what if they're actually a feature that can lead to innovative problem-solving? This article explores how we can reframe our perspective on AI hallucinations and leverage them for creative solutions.