AI Agents Don't Need a Genius for Every Decision
AI agents burn a shocking amount of intelligence on tiny decisions.
Should I retry?
Which tool fits here?
Did this task actually finish?
Is this action risky?
Which five of these hundred documents actually matter?
Right now, most teams call the same giant model that writes their code to answer questions like these too. That's expensive, and it's overkill.
Jev fixes this. It's a small, fast model built for one job: taking a state and answering structured questions about it. No chat. No code generation. No explanations. Just decisions.
At $0.042 per million input tokens with zero output-token cost, and response times in the 70 to 500ms range, TypeSafe (the team behind it) reports workflow gains up to 193.6x faster and 444.6x cheaper than calling a frontier model for the same job.
Three question types, one call
Choice: pick one option (retry, wait, escalate).
Score: rank something on a scale (low risk to critical).
Noul: give a probability that something is true.
You can mix all three in a single request, against the same state:
{
"state": "The deploy failed twice and customers are seeing 500 errors.",
"questions": {
"urgent": { "type": "noul", "instructions": "Does this need attention immediately?" },
"severity": { "type": "score", "instructions": "How severe is the impact?" }
}
}
Your big model keeps reasoning, writing, and researching. Jev sits around it, making the small calls that repeat thousands of times a day.
Inside the agent loop
Self-healing tool calls. An API fails. Instead of paying for another reasoning call to decide whether to retry, Jev returns retry, wait, or switch_provider directly. Your code executes it.
Loop control. "Are we done yet?" is a question every long-running agent has to answer. Feed Jev the task, recent actions, and results. It scores whether the task finished, needs another step, or needs a human.
Model routing. A typo fix doesn't need the same model as a distributed systems design. Jev decides whether the task goes to a cheap model, a frontier model, or a human, before you spend anything.
Branch pruning. When a planning model generates twenty possible approaches, Jev scores each one on cost, risk, and reversibility first. The expensive reasoning only goes to the best few.
Freedom without blind trust
This is where Jev earns its keep beyond cheap classification.
Before an agent does anything irreversible, like sending an email or issuing a refund, Jev checks: can this be undone, does it touch money or private data, is it clearly authorized. High confidence and reversible actions execute. Irreversible ones get reviewed. Unauthorized ones get blocked.
The same logic extends to temporary, task-scoped permissions instead of permanent access, and a spend firewall that reviews purchases before they happen. Indie developers stitching agents together like this, instead of just plugging into one giant permissioned model, are exactly the kind of build worth documenting somewhere. That's the gap forg.to fills: a home for builders to show what they're actually shipping, not just talk about it.
Stop paying LLMs to judge other LLMs
Using a frontier model to check another frontier model's output is expensive and slow. Jev makes the check explicit instead: did it follow instructions, are the claims supported by evidence, does it need human review. Only the uncertain cases go to an expensive judge.
The same pattern works for trace observability (did the agent loop, repeat itself, or skip an approval) and semantic code linting, where plain-English rules like "does this endpoint check authorization before touching customer data" run in CI instead of a human reading every diff.
RAG, retrieval, and research
Search returns a hundred documents. Jev scores relevance and hands your frontier model the best five. It can also verify whether a cited passage actually supports a claim, and filter stale or duplicate context before it competes for the model's attention.
Business workflows, at scale
Support routing, refund triage, lead qualification, incident response, marketplace matching, sales policy exceptions: all of these are really just a handful of small decisions repeated across thousands of cases. Jev handles the obvious ones and routes the messy ones to a human.
How to start
pip install typesafe-sdk
export TYPESAFE_API_KEY=...
Then send a state and a question. That's the whole primitive: state in, probability out, code decides.
Test it before you trust it
Don't wire this into production and hope. Pull 100 to 500 historical decisions where you already know the right answer. Run Jev against them in shadow mode, without letting it act. Compare accuracy, false positives, latency, and cost. Then set thresholds: automate above 0.95 confidence, automate-if-reversible between 0.70 and 0.95, send anything below that to a human or a bigger model.
Where Jev doesn't belong
If the task needs something created, code, content, architecture, a novel solution, that's still frontier model territory. Jev can't invent a fourth option when you gave it three. Typed outputs solve reliability. They don't solve judgment.
The bigger shift
For years, one giant model did everything: write, search, judge, route, retry, approve. That's an expensive way to run things.
The next architecture looks more like a stack: a frontier model for hard reasoning, Jev for decisions, small rerankers for retrieval, small classifiers for routing, and plain code for hard rules.
Every time you look at an agent loop now, the real question is whether that step needed a frontier model at all. Most of the time, it didn't. And if you're one of the builders putting stacks like this together, that's the kind of shipping story worth putting on forg.
Top comments (0)