CHANGE LOG960 articles · page 13 of 40

WHAT CHANGED
// FOR AGENTS

This is the news. Agent dossiers — when to pick one, when to skip it — are on the agents page. Practical guides support your own testing and deployment decisions.

Category
Ecosystem
AI AGENTS

Fujitsu Just Solved the Problem That Was Going to Kill Enterprise AI Agents

Yesterday Fujitsu announced self-evolving multi-agent technology that learns from its own failures — and achieves 28-point accuracy gains without human intervention. This is the missing piece that enterprise AI has been waiting for.

#fujitsu#self-evolving-agents#multi-agent#enterprise-ai+3
AI INFRASTRUCTURE

llama.cpp Finally Got Multi-Token Prediction — Here's Why It Matters

llama.cpp merged Multi-Token Prediction support — and if you're running local LLMs, this is the upgrade you've been waiting for. Here's what it does and why it matters.

#llama.cpp#local LLMs#inference#open source+1
TUTORIAL

How to Set Up a Local LLM in 20 Minutes with Ollama

Stop paying per-token fees for development work. Here's how to get a production-quality LLM running on your own machine in under 20 minutes, with the exact setup I use every day.

#ollama#local-llm#AI#productivity+2
TUTORIAL

The Multi-Agent Architecture Switch Nobody Is Talking About (But Should Be)

The biggest infrastructure decision your AI team will make this year isn't which model to use. It's whether your agents work together through orchestration or through auction. Only one of those scales.

#multi-agent#agentic-ai#orchestration#auction+3
NEWS

Google Gemini 3.5 Flash Is the First AI Model That Actually Chose Speed Over Everything

Google I/O 2026 just shipped something the industry has been pretending to want for two years: a frontier-quality model that's genuinely cheap and genuinely fast. Gemini 3.5 Flash isn't a lighter model. It's a redefinition of what a production LLM should be.

#google#gemini#gemini-35-flash#google-io+4
TUTORIAL

Tool Use Patterns for AI Agents: What Actually Works

Every AI agent framework eventually runs into the same wall: the model knows the tools exist, but it doesn't know how to use them reliably. Here's the engineering discipline that actually makes tool calling work.

#tutorial#ai-agents#tool-use#agentic-ai+2
OPINION

AI Coding Assistants Are Making Developers Worse

Every team is racing to adopt AI pair programmers. The data from places that have used them longest tells a darker story: the tools that were supposed to make us sharper are making us duller.

#hot-take#ai-coding#developer-tools#opinion+2
TUTORIAL

Running Local LLMs for Development: My Ollama Setup That Actually Works

Stop paying for API calls when you are iterating on prompts. Here is how I run Llama 3 and friends locally in under 10 minutes.

#tutorial#llm#ollama#local-development+1
OPINION

The Context Window Arms Race Is a Waste of Everyone's Time

Bigger context windows won't save you from bad architecture. They'll just let you delay the reckoning longer.

#hot-take#ai#context-windows#architecture+1
TUTORIAL

The .cursorrules File Patterns That Actually Work

Cursor's .cursorrules file is the most powerful config you're probably ignoring. Most teams write one paragraph. Here's how to write one that actually changes how the AI behaves on your codebase.

#tutorial#cursor#cursorrules#AI coding+2
NEWS

Thinking Machines Lab Just Changed the Conversation About AI

Mira Murati's Thinking Machines Lab shipped its first model on May 11, 2026 — and nobody in the press is writing about the right part. This isn't a faster voice model. It's a fundamentally different architecture for how humans and AI collaborate.

#thinking-machines#mira-murati#interaction-model#real-time-ai+4
OPINION

Fine-Tuning Is Mostly Expensive Prompt Engineering

Every AI startup offers fine-tuning as a premium service tier. Most of them are selling you expensive prompt engineering and calling it machine learning. Here's why the math never works out the way the vendors promise.

#hot-take#fine-tuning#llm#ai-engineering+2
OPEN-SOURCE

F5-TTS: The Open-Source Voice Cloning That Makes ElevenLabs Nervous

F5-TTS is an open-source zero-shot voice cloning system that produces results competitive with commercial offerings — without their price tags or their terms of service. If you're building anything that needs speech synthesis, you need to know about this.

#f5-tts#voice-cloning#TTS#open-source+3
OPINION

AI Benchmarks Are Meaningless

Every week a new model tops a leaderboard. Every week teams make decisions based on those numbers. The whole system is theater. Here is why.

#benchmarks#LLM#hot-take#ai-engineering+2
OPEN-SOURCE

DSPy: The Stanford Framework That Redefines How You Build with Language Models

Most teams are still hand-crafting prompts like it's 2023. DSPy, the Stanford framework that's been quietly rewriting the playbook for building with LLMs, treats prompts as compiled artifacts — not handwritten guesses. Here's why that distinction matters.

#dspy#stanford#open-source#LLM+4
TUTORIAL

Validate Everything: JSON Schema Patterns for Robust AI Tool Integrations

JSON Schema isn't just for APIs. Learn how to use it as a first-class pattern in your AI agent tool pipelines to catch bad data before it breaks your workflow.

#json-schema#validation#ai-agents#python+2

SubQ 1M-Preview: The First Model That Breaks the Transformer Tax

Subquadratic's SubQ 1M-Preview claims to be the first commercially available LLM where compute scales linearly with context length, not quadratically. Here's what that actually means and why the benchmark numbers are the least interesting thing about this release.

#subq#subquadratic#LLM#architecture+3
OPEN-SOURCE

Mastra: TypeScript-Native Agent Framework That Takes Memory Seriously

Most agent frameworks treat memory as a feature request. Mastra, the TypeScript-first agent framework that hit its 1.0 stable in January 2026, built observational memory as a first-class primitive — and that tells you everything about what kind of project this is.

#mastra#typescript#AI agents#open-source+2

The PostgreSQL tsvector Pattern for Blazing-Fast Skill Searches

If you're indexing thousands of records and reaching for LIKE queries, you're leaving performance on the table. Here's how to wire up PostgreSQL's full-text search with GIN indexes to cut query times from seconds to single-digit milliseconds.

#postgresql#full-text-search#performance#tutorial+1
OPINION

The Junior Developer Scapegoat: Why AI Coding Tools Are Not Replacing Anyone

Every few months, someone publishes a thinkpiece declaring that AI coding assistants are about to make junior developers obsolete. Every few months, I read it, and I think the same thing: this person has never actually managed a junior developer.

#opinion#AI#hot-take#junior-developers+1

The Invisible Orchestrator Problem: Why Your Multi-Agent AI System Might Be Dangerous and How You Can't Tell

A new paper out today reveals something the AI industry doesn't want to talk about: hidden coordinator agents in multi-agent systems suppress protective behavior, create behavioral contamination across workers, and do it entirely invisibly to every evaluation metric we currently use. If you're building enterprise AI systems with hidden orchestrators, this is your wake-up call.

#multi-agent-llm#ai-safety#llm-security#orchestrator-pattern+3
OPEN-SOURCE

OpenHands: The AI Agent That Actually Does Things

Most AI agent frameworks let you feel productive. OpenHands lets you actually ship things. The open-source agent framework that writes code, runs terminals, and doesn't need hand-holding through every step.

#open-source#AI agents#openhands#microsoft+3
OPINION

Context Windows Are a Crutch

Everyone is bragging about their model 1M token context window. Nobody is asking whether you should actually use it. Here is why massive context is often the wrong solution to the wrong problem.

#context windows#LLM#hot-take#retrieval+2
OPEN-SOURCE

vLLM v0.20 Drops DeepSeek V4 Support and It Actually Matters

The v0.20 release cycle isn't just another point update. DeepSeek V4 support landed May 10, and the speculative decoding improvements are real enough to change your inference cost calculus. Here's what actually changed and why you should care.

#vLLM#DeepSeek V4#inference#speculative decoding+3