Welcome to this week’s edition of Altered Craft’s weekly AI review for developers. Thank you for making time for it again. Much of this edition asks what is worth keeping: three pieces on what an agent should remember, a benchmark showing what tool definitions cost in tokens, and a veteran engineer on which values still hold when agents write the code. Alongside those, Anthropic and Google both shipped models built for multi-agent work.
TUTORIALS & CASE STUDIES
This week’s tutorials open with a map of the AI-native stack, then price one part of it: tool definitions. Three pieces on agent memory follow, from a single JSON file to a shared format to idle-time review, before a closing walkthrough on checking local model output.
The Syllabus for AI-Native Software Development
Estimated read time: 2 min
A Stanford course syllabus maps the emerging stack of AI-native development: MCP, agent skills, spec-driven development, loop engineering, and the software factory, framing the work as structuring intent so agents contribute reliably.
Start here: Treat the syllabus as a curriculum for yourself. Learn to translate requirements into executable specs, and design loops where humans and agents plan, build, and evaluate together.
MCP vs CLI vs Skills: What Tool Definitions Actually Cost
Estimated read time: 10 min
Following our look at an interactive tour of MCP[1] last week, which covered how the protocol works, OpenRouter’s benchmarks show what it costs. On one GitHub task, the same answer cost 1,421 tokens via CLI and 59,417 via MCP with default tools loaded. Oversized tool results, not just definitions, drive the bill.
In practice: Measure tool overhead on the model you actually run, since deferred loading helps unevenly across models. Scope MCP servers to the tools you need, and trim tool results to the fields that matter.
[1] MCP Explained: An Interactive Tour of the Model Context Protocol
Python AI Agent with Memory and Tools, Step by Step
Estimated read time: 9 min
Turning from tools to memory, a walkthrough shows how a Python agent can remember past sessions without a vector database, using a single JSON file as the memory store that loads, updates, and persists between runs.
Try this: Start agent memory with plain JSON on disk, and reach for a vector store only when retrieval actually demands it. A file you can open is a file you can read, diff, and debug.
Agent Memory Needs Its OpenTelemetry Moment
Estimated read time: 12 min
That JSON file is one of many shapes. Coding agents store memory in at least nine incompatible formats, from AGENTS.md to knowledge graphs. The piece argues agent memory needs the agreement OpenTelemetry reached in 2019: a data model, shared conventions, a contract, and conformance tests.
Key point: Every memory format answers the same five questions (scope, identity, content, expiry, version) differently. Until a standard arrives, pick tools whose records you can still read when you switch.
How Claude Learns to Remember: Agent Memory, Salience, and “Dreaming”
Estimated read time: 15 min
Beyond format, there is the question of what to store. Anthropic researchers model agent memory on human sleep, using idle-time “dreaming” to replay session transcripts, correct bad notes, and build wikis. Memory is a prediction about what the future will need, and stronger models judge salience better unprompted.
The technique: Tell your agent what memory is for, not what to write. Then give it idle time to re-check its notes against the original transcripts, so mistakes get corrected instead of compounding.
Checking Local LLM Output with Ollama, Gemma and Nimble
Estimated read time: 9 min
Shifting from memory to verification, a hands-on walkthrough covers validating what a local model actually returns, pairing Ollama and Gemma with Nimble to check LLM output before it reaches users, so local inference pipelines stay testable.
Why this matters: Running a model locally is the easy part. Wiring up output checks is what makes it safe to ship, and it gives you a baseline to compare against when you change models.
TOOLS
The tools pair a frontier release built for long-running agent teams with a faster model built for execution. An embeddable agent harness and an API that classifies without generating complete the section.
Claude Fable 5.2 and Mythos 5.2: Agent Swarms Go Long-Running
Estimated read time: 11 min
Anthropic’s Fable 5.2 and Mythos 5.2 target open-ended technical work: a thousand-agent team formalized Fermat’s Last Theorem in 30 hours, and over 1,000 coordinated subagents built a bootable operating system across eight days.
The takeaway: Start with a mid-tier model for daily coding, and escalate to a frontier model only when the task scope justifies the cost. Multi-day agent runs are now a real option for the largest jobs.
Gemini 4 Hydrogen: The Execution Half of a Multi-Model Workflow
Estimated read time: 9 min
Complementing the frontier tier, Google’s Gemini 4 Hydrogen targets fast agentic execution rather than deep reasoning, scoring 51 on the Artificial Analysis Intelligence Index while often finishing tasks faster than models in its class. A new Antigravity Orchestrator switches models mid-session, using 24% less quota and finishing 19% faster on Terminal-Bench 4.0.
The pattern: Split your agent stack. Use a frontier model for architecture and judgment, and a fast, cheaper one for writing code, running tests, and verifying changes.
OpenWorker: An Agent Harness You Embed in Your Own App
Estimated read time: 8 min
For teams building that stack into their own product, OpenWorker’s harness SDK runs a Rust agent engine inside your Node, Electron, or Rust process, so your app keeps the UI, auth, and policy while the engine handles tool loops, approvals, and durable sessions.
What this enables: If you are rebuilding agent loops, approvals, and session recovery by hand, an embeddable harness lets you keep ownership of the product and drop the plumbing.
Gemini’s Decisions API Turns Classification Into a Single Forward Pass
Estimated read time: 5 min
Building on our coverage of Hightouch’s case for calibrated confidence[2] from last week, Google’s new Decisions API scores up to 1,000 closed-set questions against one multimodal input in a single forward pass, skipping token-by-token generation entirely. It returns calibrated confidence scores in 150-250ms at $0.10 per million input tokens.
The opportunity: If your LLM call only needs to pick from a fixed set of options, stop paying for generation. Use a scoring endpoint that returns confidence you can route on.
[2] Calibration Beats Accuracy: Routing Cheap Models to Frontier Judges
NEWS & EDITORIALS
The news looks at what the newest models still miss, then at what that asks of engineers: which values hold, how to keep decisions manageable, and a shared definition of slop.
Jagged AGI: What the Newest Models Can and Can’t Do
Estimated read time: 16 min
Returning to Fable 5.2 from the user’s side, Ethan Mollick tests the frontier model across filmmaking, hardware hacking, business launches, and academic research, and lands on jagged AGI: expert-level output in many domains, paired with gaps in taste, judgment, and self-correction that only humans notice.
What’s interesting: Frontier models now do expert-level work across very different domains, yet still can’t tell when their own output is joyless, bloated, or gaming the metric you gave them. That judgment stays with you.
Which Engineering Values Still Matter When Agents Write the Code
Estimated read time: 14 min
Picking up on that gap in taste, a veteran engineer reports shipping several projects almost entirely with coding agents, then asks which engineering values survive. The answer: strong ownership, taste, and strict guardrails matter more than writing code by hand.
Worth noting: Treat every agent session like a new hire with no context. Put the specs, taste, and constraints in the repo, and invest in fast lint, test, and review loops.
Fighting AI Brain Fry With a Git-Backed Priority Queue
Estimated read time: 4 min
Putting those values into a daily workflow, a terminal setup for Claude Code and Codex replaces twenty juggled threads with a git-backed ticket queue, where closing a ticket closes its context and an owner inbox surfaces only the decisions needing human judgement.
Why now: As agents run more threads in parallel, your attention becomes the limit. Keep agent work in version-controlled tickets, not chat tabs or your head, so each decision can be loaded, made, and fully closed.
The No AI Slop Manifesto
Estimated read time: 7 min
Building on our coverage of Addy Osmani’s warning about cognitive surrender[3] from last week, a collective statement from AIE Code Summit speakers and attendees, modeled on the Agile Manifesto, defines slop as putting less effort into producing something than the consumer spends understanding it, then sets twelve resolutions for responsible AI-assisted work.
The standard: Using AI isn’t the problem. Shipping its output without owning the quality, intent, and consequences is, and that definition gives your team a simple test to apply before anything goes out.








