Radar

I explained the same project to Claude Code, then to Codex, then to a browser agent, in the same week. Each one did fine. Each one started from nothing. The bottleneck in my multi-agent setup right now is not reasoning, it is that every tool behaves like a new hire on their first day.

A small pile of projects landed this summer to fix exactly this. Memmy runs a local memory hub and scans your existing agent histories to turn months of accumulated context into something all of them can read. Memorix does the same over MCP across more than a dozen clients. Different bets, same observation: the interesting state is not in any one tool's session, it is in the overlap between them, and nobody was storing the overlap.

What makes me think this sticks is that it is the natural next step after context engineering. We got good at deciding what goes into one window. We never decided where it lives between windows. Local-first is the right default here too, because a shared memory of how you work is roughly the most sensitive artefact your tooling will ever produce. I would rather that file sit on my disk than in someone's product roadmap.

Two years ago LLM observability was a nice-to-have you added after the first bad week. The current crop — Langfuse at 28,000 stars and MIT licensed, Phoenix, MLflow, and the paid tiers above them — has turned it into the first thing a serious team installs, and I think the reason is agents rather than models.

A single model call is easy to debug. You have the prompt, you have the answer, you can read both. An agent doing forty tool calls across six hours is a distributed system, and you are back to needing exactly what distributed systems always needed: a trace, a span, and a way to find the one step where it went wrong. The industry rediscovered observability from first principles, which is funny to watch and slightly embarrassing for all of us.

The one thing I would push on is where the traces live. Your traces contain the actual prompts, the actual retrieved documents, and the actual customer inputs. That is a more sensitive dataset than your database in a lot of products, and it is worth deciding on purpose whether it leaves your infrastructure. That is the real argument for the self-hostable options, not the licence.

The 2026-07-28 spec for the Model Context Protocol rewrites the core transport, deprecates three long-standing features, hardens authorization against OAuth and OpenID Connect, and promotes MCP Apps and Tasks to first-class extensions. Nothing about it will trend. It is the most consequential agent release of the last two months anyway.

The practical change is that a remote MCP server used to need sticky sessions, a shared session store, and a gateway smart enough to inspect traffic. Now it runs behind a plain round-robin load balancer and clients can cache the tool list. If you have ever operated anything at scale you know exactly what that sentence is worth. It is the difference between a demo you babysit and a service you page someone about.

Protocols get boring in a specific order: first they work, then they scale, then they grow a deprecation policy. MCP now has all three, including a promise that deprecated features keep working for twelve months. That is not a research milestone. It is the sound of agents moving from the lab into the part of the org that has an on-call rota.

August 2nd was supposed to be the day the high-risk rules bit: risk management, data governance, technical documentation, human oversight, conformity assessment, the full market surveillance framework. Then on July 27th the Digital Omnibus entered into force and pushed the standalone high-risk obligations out to December 2027, and the ones embedded in products to August 2028.

Two years of compliance programmes, external auditors, and internal readiness reviews, rescheduled with five days' notice. I have some sympathy for the reasoning, because the harmonised standards the rules depend on genuinely were not finished, and enforcing a requirement nobody can yet certify against is theatre. But the signal it sends is unambiguous, and every company that spent real money getting ready has now learned that the ones who did nothing were right.

The uncomfortable lesson is not about Brussels. It is that regulation is now moving slower than the thing it regulates, by a margin that keeps widening. The transparency rules did land, so chatbots do have to say they are chatbots and synthetic media does have to be labelled. That is a real change. It is also a very small one next to what got postponed.

Moonshot put the full weights of Kimi K3 on Hugging Face: 2.8 trillion parameters, a mixture of experts that only fires 104 billion of them per token, native vision, a million-token context, and coding scores that trade blows with the closed frontier. It is the largest open-weight model anyone has released. The download is about 1.4 terabytes.

That last number is the whole story. We have spent years arguing about licences as though the licence were the barrier, and Moonshot just proved it is not. The weights are yours under permissive terms. Actually serving them needs a rack of accelerators most companies do not own and no individual does. Open used to mean "you can run this." Now it increasingly means "you can audit this, fine-tune this, and rent someone else's hardware to serve it."

I do not think that is a betrayal of open source, but it is a different bargain and worth naming out loud. The value has quietly moved from the file to the infrastructure. Kimi Delta Attention making long-context inference several times cheaper is the part that will matter in a year, because the constraint on open models is no longer permission. It is electricity.

Anthropic shipped Opus 5 at $5 per million input tokens and $25 per million output, roughly half what the comparable frontier models charge, with a million-token context and state of the art on Frontier-Bench and GDPval-AA. The benchmark line is nice. The price line is the actual news.

Here is why. For the last two years the frontier was priced like a luxury good, so the honest engineering answer was always "use the cheap model for the boring 90% and save the expensive one for the hard 10%." That routing logic is a tax. Every team building on models pays it in complexity, in latency, in bugs that only show up on the cheap path. When the best model costs half of what it used to, a lot of that machinery becomes something you can just delete.

The effort dial matters for the same reason. Low, medium, high is not a feature about intelligence, it is a feature about cost. It puts the trade-off in one parameter instead of in your architecture. I keep saying the frontier stopped being a leaderboard and started being a supply chain, and this is what that looks like in practice: the interesting number moved from the score to the invoice.

Etched burned two Harvard dropouts' years and around $800M on a single idea: build a chip that does one thing, run transformer inference, and refuse to do anything else. Sohu is an ASIC, so there is no flexibility to fall back on if the field moves. TSMC produced it in early 2026, the company booked over $1B in forward contracts, and the valuation went from $5B to $10.3B in about seven months.

The bet underneath is architectural, not commercial. A general-purpose GPU is expensive insurance against the next big idea. Etched sold the insurance and kept the cash, wagering that the transformer is now settled infrastructure the way x86 became settled infrastructure, and that the remaining gains come from specialising rather than from redesigning.

I think that is probably right and I still find it slightly unnerving. Every hardware generation that hardcodes an assumption also makes that assumption harder to abandon, because now billions of dollars of silicon are voting for it. We have spent three years saying attention is all you need. Somebody just etched it into a wafer.

Pydantic AI v2's capability is a bundle of tools, instructions, hooks and model settings that serialises cleanly, which means you can define a whole agent in YAML and never write the Python. The docs make a point of it: the surface is small enough that a model can write the spec for you.

I like this a lot and I am wary of it in equal measure. The upside is real — a declarative agent is reviewable in a pull request, diffable, testable, and legible to someone who does not know the framework. That is a genuine improvement over five hundred lines of imperative wiring that only its author understands.

The worry is the failure mode we already know from every other config-driven system. Behaviour that lives in YAML tends to escape the tests, because YAML does not look like code and nobody writes a unit test for a settings file. Then it grows conditionals, then templating, then a small unhappy language of its own. If you go this way, treat the spec as source: it goes in the repo, it gets reviewed, and something in CI actually runs it.

GPT-5.6 did not arrive as a model. It arrived as three: Sol at the top, Terra in the middle, Luna fast and cheap, at $5, $2.50 and $1 per million input tokens respectively. Alongside it came ChatGPT Work, an agent built to finish jobs rather than answer questions.

The naming is the interesting decision. Sol, Terra and Luna are meant to be durable tiers that each move on their own cadence, so next year's Terra can improve without anyone having to relearn what to reach for. That is a small thing that quietly fixes a real problem: every version bump used to force teams to re-benchmark their whole routing layer. Now the tier is a stable contract and the version is an implementation detail.

The number I keep turning over is Altman's claim that Sol is 54% more token-efficient on agentic coding. Not smarter. Cheaper per unit of finished work. That is the second frontier lab in a month to lead with efficiency rather than capability, and it tells you where the competition actually is now. Everyone can reason. The fight is over who can afford to let a model think for an hour.

Look at the top of the intelligence index right now: Claude Opus 4.8, GPT-5.5, Gemini 3.1 Pro, Grok 4.3, all separated by a handful of points. When the smartest models are effectively tied, "which one is smartest" stops being a useful question.

So the real question quietly changed. It is no longer which model reasons best on a benchmark, it is which one you can actually put to work. Cost per real task. How it behaves when it is uncertain. Whether it can run a long, messy job without a human babysitting every step. Opus 4.8 shipping an effort dial and admitting when it doesn't know is a bigger deal to me than another point on a leaderboard.

2026 is the year models stopped being chatbots and started being coworkers. The winners won't be the ones that top a benchmark for six weeks. They'll be the ones you trust to finish something while you're asleep.

Pydantic AI v2 went stable on 23 June. LlamaIndex Workflows 1.0 followed within a day. Vercel shipped AI SDK 7 on the 25th. Microsoft folded Semantic Kernel and AutoGen into one framework. Four independent teams, one window, and near-identical release notes: durable execution, human approval on tool calls, telemetry, and a serialisable agent definition.

When competitors converge that hard that fast, they are not copying each other. They are all hitting the same wall at the same time, which is what happens when a technology finishes its prototype phase. Nobody needed durability when an agent ran for eleven seconds. Everybody needs it the moment an agent runs for six hours and a deploy lands in the middle.

The useful thing to take from it is that the framework choice matters much less than it did a year ago. The abstractions have converged, so pick on the language you already write, the runtime you already operate, and the team that will still be maintaining it in two years. The interesting differences moved down a layer, into whether your durable execution runs on Temporal or on something you now have to babysit yourself.

Inside DeepMind's AlphaProof Nexus setup, Gemini 3.1 Pro drove a loop with the Lean proof compiler and closed 9 of 353 open Erdős problems, two of which had been unsolved for 56 years, plus 44 conjectures from the integer-sequence encyclopedia. Every result is machine-checked, so there is no hand-waving about whether the proofs hold.

This is the kind of headline that gets flattened into "AI does math now," which misses the point. The model wasn't a calculator. It was the search engine over a space of possible proofs, proposing ideas while a formal verifier ruthlessly threw out the wrong ones. Creativity from the model, certainty from the compiler.

That pairing is the template I expect to see everywhere: a strong generator plus a strict checker. It maps cleanly onto Karpathy's line that LLMs will automate anything humans can verify. Math just happens to be the domain where verification is airtight, which is exactly why it fell first.

Peter Steinberger built a personal AI assistant in roughly an hour, renamed it twice to dodge trademark complaints, and watched it climb past 380,000 stars to sit at number one on GitHub. Under five months, weekend project to the most-starred repo in the world.

The reflex take is that this is hype, a star-count sugar rush. I don't buy that. What OpenClaw actually proves is that the cost of building something people want has collapsed. One person, working with agents, shipped a cross-platform assistant that plugs into WhatsApp, Slack, and Discord, and it was good enough to spread on its own.

The lesson isn't "quit your job and vibe-code a unicorn." It's that distribution now rewards taste and speed over headcount. The bottleneck moved from writing the code to knowing what is worth writing. That is a very different game, and most teams haven't adjusted yet.

DeepSeek dropped V4 as open weights, a 1.6T-param Pro and a leaner Flash, and the benchmarks put it shoulder to shoulder with the closed frontier on coding and agentic work. A year ago people called the first DeepSeek moment a fluke. Two flukes in a row is just a strategy.

Here is what I keep coming back to. Every time an open model lands within a few points of the best closed one, it resets the price everybody else can charge. You cannot sell water by the bottle next to a public fountain that tastes almost as good. The frontier labs still lead, but the gap they can monetize keeps shrinking.

For anyone building on top of models, this is the best news of the quarter. It means you can prototype on a closed API for quality, then swap to open weights for cost and control, without rewriting your assumptions. Optionality like that used to be a luxury.

Karpathy pushed 630 lines of Python to GitHub and went to sleep. By morning, his AI agent had run 50 experiments and committed the results to git. No human input in between.

The tool is called autoresearch — and it's now the most viral open-source AI project of the month.

The setup is almost too simple. You write research instructions in a Markdown file. An AI agent reads it, modifies a training script, runs a 5-minute experiment on a single GPU, checks if validation loss improved, keeps or reverts, and repeats. 12 experiments per hour. ~100 overnight.

After 2 days and 700 experiments: 20 genuine improvements that stacked, an 11% training speedup on code he thought was already optimized, and a bug in his own attention implementation he'd missed for months. The agent caught it.

Been using Claude Code for a week now and it's genuinely changing my workflow. The agentic loop + file editing combo means I can describe architecture-level changes and watch them materialize. Not perfect, but the iteration speed is wild.

A 1.2B parameter model just ran chain-of-thought reasoning in my browser tab. No API. No server. No bill.

Liquid AI dropped LFM2.5 and the WebGPU demos are wild. Vision model does real-time webcam captioning, fully client-side. Thinking model runs chain-of-thought reasoning in a browser tab at 0.28 seconds.

Beats Llama 3.2 1B on GPQA, MMLU Pro, and IFEval benchmarks. Static deployment ships as HTML/JS/WASM — host on any CDN with zero inference cost.

This is what edge AI was supposed to look like.

Google quietly built the most complete agentic AI ecosystem in the industry. And nobody's talking about the full picture.

Models + Tools + Frameworks + Protocols. Gemini 2.5 Pro, ADK (Agent Development Kit), A2A protocol. 750M+ Gemini users, 18.3K ADK stars, 150+ A2A partners.

While everyone's focused on individual model benchmarks, Google assembled the full stack for agentic AI: the models, the developer tools, the communication protocols, and the distribution.

Every team I talk to is building RAG. Almost none of them have good evaluation. We default to vibes-based testing — "does this answer look right?" — and call it done. The gap between building RAG and knowing if it works is massive.

Alibaba's Qwen just became the #1 open-source AI family on the planet. 700M+ downloads. 90,000+ derivative models. The top 4 spots on HuggingFace. All in 3 years.

From a small Alibaba experiment to dominating every global leaderboard — this is one of the most underrated stories in AI right now.

The company that built its reputation blocking bots just launched a web crawling API.

Cloudflare quietly dropped a /crawl endpoint this week. One API call, and you get clean, structured content from any URL. The irony is beautiful — and the implications for RAG pipelines are massive.

If you're building any kind of retrieval system, this changes the data ingestion game completely.

Every local LLM user has done this. Download a model. Wait 20 minutes. Launch it. Watch it crawl at 3 tokens per second — or not load at all.

The gap between cloud inference and local inference is still massive. But tools like llmfit are starting to close it — optimizing models for your specific hardware, quantization level, and memory constraints.

The future of local AI isn't just about smaller models, it's about smarter deployment.