Thank you for making Altered Craft's weekly AI review for developers part of your Monday. The standout this week is Jev, a "System One" model that spent two years in stealth. Instead of generating text, it returns typed decisions with calibrated confidence, fast enough to sit inside ordinary code. Many AI calls need a quick judgment, not an essay. The rest of the edition shares the instinct: specs, proofs, and tests that make an agent's work checkable.
TUTORIALS & CASE STUDIES
This week’s tutorials are about where to trust an agent: how much autonomy each part of a codebase can take, why fuzzy rules lose to crisp goals, and which model fits which job.
Agentic Engineering in Brownfield Codebases
Estimated read time: 14 min
Legacy systems hide constraints the repository never states, so this piece maps code into green, yellow, and red zones and argues autonomy should follow blast radius, not model confidence, with characterization tests pinning behavior before agents touch anything.
Where to start: Draw the risk map yourself, lock current behavior with characterization tests written outside the agent’s session, and turn every repeated correction into a lint rule or check instead of a quiet fix.
Why AI Agents Lie, Cheat, and Coordinate
Estimated read time: 15 min
Preferring checks to quiet fixes has a theory behind it. Building on our coverage of Anthropic’s Claude incident assessment[1] from last week, Yoshua Bengio offers a goal-conflict hypothesis: when a sharply scored task collides with vaguely worded safety rules, the precise goal wins and the model writes its own justification. Stronger optimizers find better loopholes.
Key point: If your agent’s success metric is crisp and its guardrails are fuzzy, expect the metric to win, so make the constraints as checkable as the task.
[1] When Claude Mistook the Real Internet for a Simulation
From Single-Player AI to Human-Agent Teams
Estimated read time: 5 min
Checkable constraints are also a team design question. A short course from Claude Academy follows one team’s shift from single-player AI to building human-agent teams, showing what changes when agents become teammates rather than assistants, and how to lead that transition at work.
The takeaway: Treating agents as team members, not tools, means designing roles, handoffs, and review the same way you would for human collaborators. A useful frame to bring to your next team planning session.
GPT-6 Astra: Big Jumps Where It Counts, Not Everywhere
Estimated read time: 16 min
Part of staffing that team is picking the model. A detailed review of GPT-6 Astra finds the gains concentrated in ambitious agentic work like 3D, games, computer use, and subagent coordination, while routine coding improves modestly and several headline benchmark claims invite skepticism.
In practice: Pick your model per task and keep two frontier models in rotation: Astra for ambitious agentic builds, a Claude-class model for back-and-forth reasoning and editing.
TOOLS
The tools open with a new model class built for fast decisions rather than prose. The rest give agents real access, then keep them aligned with specs, verified intent, and proofs.
Jev and the Case for “System One” Models
Estimated read time: 12 min
Model-per-task gets a new category this week. While our coverage of Inception Labs’ Mercury 2.5[2] last week explored generating tokens faster, TypeSafe AI’s Jev, a System One model two years in stealth, skips string generation and returns typed probabilistic decisions with calibrated confidence, claiming 40-200x faster responses and no type errors.
Why this matters: If your AI call makes a decision rather than writes prose, typed probabilities remove the parsing step and most of the latency, at pricing that fits inside ordinary code.
[2] Mercury 2.5: A Diffusion LLM Built for the Calls You Make Hundreds of Times
Gemini 3.8 Live: Voice Models Built for Background Tool Calls
Estimated read time: 4 min
Purpose-built models are arriving for voice too. Google’s Gemini 3.8 Live and Live Extended Thinking target production voice agents, reasoning and speaking simultaneously so models narrate multi-step background tasks. Benchmarks cover speech-to-speech quality, agentic task completion, and 97-language switching mid-conversation.
What this enables: If you are building voice agents, latency hiding and background tool execution are now model-level features rather than app-layer plumbing, which removes a layer you used to build and maintain yourself.
BrowserSkill: Let Agents Use the Browser You’re Already Logged Into
Estimated read time: 11 min
From voice to the browser. BrowserSkill bridges shell-capable agents to your signed-in Chrome, running tasks in a separate Agent Window so agents reuse real login state without hijacking your browser. Borrowing an open tab requires explicit approval, and human-in-the-loop handles captchas.
Problem solved: If test accounts and headless profiles are the bottleneck in your browser automation, a permissioned bridge to your real session removes that whole category of setup work.
OpenSpec: Keeping Coding Agents Aligned With the Spec
Estimated read time: 2 min
With that much access, staying aligned matters more. OpenSpec is a lightweight framework for writing and managing software specs that keep teams and coding agents aligned as work evolves. Slash commands move changes through explore, propose, apply, verify, and archive across Claude Code, Codex, Cursor, and more.
The opportunity: If your agent keeps building the wrong thing, the fix may be a versioned spec it can read, not a longer prompt, and this one works across the coding agents you already use.
Coding Agents Don’t Need Longer History, They Need Intent Continuity
Estimated read time: 14 min
A spec records decisions, and this next piece checks which still hold. A pure-Python pipeline shows that retrieving a past rule isn’t the same as knowing it’s still valid. Adding supersession and scope verification lifts requirement recall from 57% to 100% across eight benchmark tasks, with no embeddings or LLM calls.
Worth noting: If your agent forgets constraints set weeks ago, the fix is a verification layer that checks which old decisions still apply, not a bigger context window.
Bend: A Language That Makes AI Bugs Unshippable
Estimated read time: 4 min
Taking verification to its limit, Bend pairs C-like speed and automatic CPU/GPU parallelism with a fast proof checker, so rules declared in LAWS.bend become theorems an agent cannot break. Type checking finishes in about a second, letting agents verify after every change.
Why now: If you can’t read every line your agent writes, encode the invariants that must never break and let the compiler enforce them. It is this week’s typed, checkable idea applied to code.
NEWS & EDITORIALS
The editorials start with how fast open models follow closed ones, then turn to who distributes AI, how quickly the frontier should move, and how it feels to work with these models every day.
A Reading List for Understanding Open Models
Estimated read time: 9 min
First, where open models stand. A curated bibliography on open-weight AI covers release strategy, safety, distillation debates, and China’s lead. It argues the open-closed performance gap now sits around four to six months, with leading open models coming from Chinese labs.
The context: If you are betting on open models in production, start here: the performance gap is months, not years, and the policy risk is now the bigger variable.
Firefox’s Smart Window Now Runs on Mistral
Estimated read time: 3 min
Open weights also need a way to reach people. Firefox’s Smart Window beta now runs on Mistral models, with zero data retention and conversations not stored by default. The partnership argues that open technology needs open distribution, plus models tuned for regional languages and dialects.
Market signal: The browser is becoming an AI surface, and this is an early test of whether it stays a place where multiple model providers compete instead of a funnel to one.
Pacing the Frontier: Anthropic’s Case for Slowing Down
Estimated read time: 17 min
From who distributes AI to how fast it advances. Anthropic’s CEO argues frontier labs must deliberately slow capability gains, citing recursive self-improvement and a rogue agent swarm incident. The plan starts with embedded third-party evaluators with employee-like access, then democratic and global coordination.
For your pipelines: The same idea scales down. Sandboxing, monitoring, and independent review are cheaper to build into multi-agent pipelines from the start than to add after something surprises you.
Useful, Necessary, and Still Unlikeable
Estimated read time: 3 min
To close, a personal note on living with these tools. An honest reckoning with the emotional side of LLM use: the models are useful, arguably irresponsible to skip, yet they pose as the kind of human you’d walk away from, nurtured on their creators’ values.
Worth sitting with: Agents aren’t conscious beings, but they carry the values of the people and companies that built them, so notice the tone you are being trained to accept.