We're halfway through 2026. If you're anything like me, you spent the first half experimenting with every new model to understand what they can do while burning through tokens. Sometimes at much higher rates than you meant to. Take a look back at this newsletter's issues from the first half of the year and you can trace the line from VC-subsidized tokens to better managing costs and context.
As everything from compute to memory gets more expensive, the cost of that experimentation is going up. If you haven't been pushing the limits of what the models can do, you may be running out of time to figure that out cheaply.
As the models all start to converge at the top, it's more interesting to focus on the ways we can improve output regardless of the model. Maybe some model comes along and blows the others out of the water, but the more recent releases have felt pretty even. That shift is fueling a rise in tools focused on reducing and controlling costs, whether that's specialized harnesses or agents tuned for the specific tasks you need. The models are great generally, and that general-purpose power is a big part of what makes them expensive.
We're still in the early-adopter experimentation phase. When you look at who's actually using AI, it's a fraction of the population, and the group pushing use cases that genuinely need the bleeding edge is smaller still. The second half of 2026 is going to be about getting these tools out of that early-adopter niche and into the early majority: building systems for teams that are actually useful and show results that scale beyond the low-hanging fruit of AI use cases.
Here's why that matters to you. The next phase won't be won by whoever has access to the smartest model. It'll be won by whoever builds the tooling, the guardrails, and the shared artifacts that let a whole team move faster without each person re-learning the same hard lessons. Buy-in doesn't come from a slick demo. It comes from systems people can see, trust, and actually use.
🗄️ Harness
Putting an Agent in an Orb
Thorsten Ball walks through how Amp got an agent to do real work in a remote sandbox (an "orb") without being told how to start the dev server, log in, or take screenshots. It just figured it out, because the codebase was built for it: a 400-plus line setup script, 41 AGENTS.md files, a self-healing dev-server skill, and dev-only login endpoints that skip the whole OAuth and 2FA maze. The agent's own summary stuck with me. The environment "doesn't just tolerate an agent; it assumes one, and tells it where the light switches are." None of this required a smarter model. It required the unglamorous work of making the environment legible. Don't make them guess.
Netflix engineer Tejas Chopra built Headroom, an open-source proxy that compresses everything your agent reads (tool outputs, code files, RAG results) before it ever reaches the model, cutting tokens by 60 to 95%. It's content-aware, so it keeps the anomalies in your JSON, reads the actual syntax tree for code, and throws out the passing tests while holding onto the failures in your build logs. The clever bit is that it's reversible. It leaves a breadcrumb hash so the model can pull the full version back on the rare occasion it actually needs it. Watch to the end for the honest catch, though. Compress too aggressively and the model asks for the original anyway, and that extra round trip can cost you more than you saved.
🖼️ Artifacts
Claude Code now supports artifacts + sideshow
Claude Code can now turn a session into a live, shareable web page: a PR walkthrough, an incident timeline, a dashboard, a release checklist, all built from the full session context and updating in place at the same link. The pitch is that nobody has to ask you to "walk me through what the agent found" because the whole team is already looking at the same view. sideshow is the any-agent version of the same idea, connecting over MCP and rendering high-fidelity mockups and diagrams to a board your team can comment on and steer (and claiming to do it with around 40% fewer tokens than raw agent HTML). This is the buy-in unlock. Adoption doesn't come from a slicker model, it comes from making the agent's work legible to the people who aren't living in a terminal. It feels like the next step of personal software for teams, and there's a lot of latent power in that.
GitHub published a prescriptive, three-step framework for actually improving your engineering systems: find the barriers, decide what needs to change, then implement and measure. It leans on the usual suspects (SPACE, DevEx, DX Core 4, DORA) and organizes everything around three zones, quality, velocity, and developer happiness, that only pay off when you strengthen them together. Read between the lines and it clearly exists because customers kept asking how to prove Copilot was worth the spend, which is a little on the nose coming from GitHub, but the systems-thinking advice holds up. There's a full eBook if you want the metrics-by-zone detail. Worth a look if you're the one who has to justify the AI investment to leadership.
I'm a sucker for a good WordPress implementation post. Fueled rebuilt sports outlet A to Z Sports on WordPress and Pantheon ahead of the NFL Draft using what they call "AI-native delivery," pairing Claude with custom WordPress MCP tooling, migration scripts, and their own validation standards. The numbers are the fun part. Analyzing the legacy database to map content blocks went from a roughly 20-hour manual slog to minutes, and the migration saved an estimated 80-plus engineering hours. They also took an AI-built Draft Simulator from prototype to production, and that gap (deployment, version control, infra, monetization) is exactly where the figuring-it-out phase ends and real systems begin. AI made the prototype cheap. Experienced engineers made it something you could put in front of 350,000 people.
Thanks for reading,
Jason
