Last updated: September 11, 2026
Code RED Newsletter #37
Two conferences in one week, eight time zones apart: Julia at KCD San Francisco Bay Area, me at ContainerDays in Hamburg. Different rooms, different continents, and by Friday we'd each had the same conversation about six times.
Almost none of it was about models. People wanted to talk about abstractions - how to make an agent framework accessible without making it dangerous, who watches the agents once they're loose in production, where organizational knowledge lives so a coding agent can use it instead of guessing. In Hamburg the version I kept hearing was also how you run GPUs and inference on bare metal (digital sovereignty?) while still delivering everything you were already on the hook for.
Nobody gets to stop running the platform because AI showed up. The pager is not impressed by your model. The model is the part you can buy; the floor underneath it is the part you have to build.
In focus: Build the Floor
A few things rhyme this fortnight. An independent newsletter did the cost arithmetic on autonomous triage, monday.com published its alerting platform and then the agent standing on it, Uber published a 24-million-node context graph, and an Anthropic reliability engineer explained why he still answers no. Different stories, same finding: the teams getting real work out of agents built something boring first. Either way, there's good reading below.
The AI SRE Runs Inefficient Queries
Allan Mann's arithmetic: humans are expensive to employ and cheap to run, agents are cheap to employ and expensive to run. A senior engineer asks two questions because they have a hypothesis. An agent has none, so "it asks ten questions where you would have asked two. It re-runs the ones that timed out."
The part I'd underline is what that does to a platform billing per query. Forty parallel queries is a budget problem; the same agent hitting a rate limit mid-incident and settling into a retry loop is an outage problem. His prescription - open formats and storage you can control, before you shop for autonomous triage - is where this issue got its title: build the floor before you buy the robot.
Fueling the AI SRE: How monday.com Standardized Observability for 600+ Services
monday.com standardized alerting across 600+ services and ten monitoring tools, using an "Observability Guard" in their developer portal. Alert definitions live as 107 JSON templates in a git repo anyone can contribute to. Thresholds get proposed from two weeks of history, using Median Absolute Deviation, instead of each team inventing its own. Opt-in ran a year and got nowhere, so baseline alerts became mandatory.
Three weeks later they published the agent standing on it. It triages from a prompt written as an operations manual, and stays read-only in production repos. Over 1,133 sessions it failed 3.4% of the time, and they published that number. Platform first, agent second. That order is the whole issue.
Running a Software Factory Efficiently at Uber Scale
Over 70% of Uber's pull requests now come from agents, at 52% lower cost per session. The number I'd point at, though, is 24 million: the nodes in their AI Context Graph, connecting services, teams, incidents, pull requests and deployments. On one query, an ungrounded agent gave up after 20 minutes; with the graph it finished in 38 seconds.
GitHub and Spotify published their own agent unit economics the same fortnight, and per an Apica-commissioned Omdia survey, 59% of organizations have already killed or delayed an agentic deployment over monitoring costs. The plug tends to get pulled by finance, not by engineering.
Code RED Podcast #49 - The Single Pane of Glass Is a Myth: AI, Telemetry and the Future of Observability
Mirko is joined by Cribl CEO Clint Sharp, and asks him about AI SREs: "I'll be on the record in saying I think that whole category is dead on arrival." His thesis is that agents commoditize the pretty parts of this industry, a decade of expertise encoded into dashboards, leaving the incumbents "terrified of being depositioned to just a database."
Halfway through, he and Mirko find the same wall from opposite sides: observability got built write-heavy and is going read-heavy, because an agent queries the way no sensible human ever has.
Can Claude Fix Itself? Using LLMs for Incident Response
Alex Palcuie does AI reliability engineering at Anthropic - unlimited tokens, researchers down the hall - and answers his own title with "It's a no. I want to sit with the no for a second." He maps incident response onto the OODA loop, where the middle two steps come out very differently.
Observing is superhuman: chasing 500s on New Year's Eve, Claude caught the fraud by connecting 22-image upload batches, 4,000 accounts sharing one email template, and request timing. Palcuie says he'd have missed it. Orienting is dangerous: when KV cache failures made duplicated requests and errors spike together, Claude kept calling it capacity rather than the cache, and corrected it in the docs six or seven times before it stuck. The risk isn't a stupid model. It's a confident wrong answer a junior engineer has no reason to doubt.
Dash0 Joins the Agentic AI Foundation
Dash0 is now a Silver member of the Agentic AI Foundation - yes, this one's by me. Dash0 is built on OpenTelemetry, you query with PromQL, the dashboards are Perses, OTelBin was built and given away, the coding agent plugins are open source, and Polar Signals brought in the team behind Parca. None of those formats are ours, deliberately.
The same principle should apply to agents, and the gap I'd point at is the one the Observability & Traceability working group exists for: we describe individual model calls well enough, and still can't describe an agent's behavior - which tools it called, what it was trying to accomplish, what happened across a whole run - without every framework inventing its own vocabulary. AAIF also introduced a Sandbox phase this week, and OpenTelemetry published a practical guide to the GenAI conventions.
How Figma Uses AI Agents for Security
Figma's security agents investigate alerts and prepare fixes over audit logs from AWS, Okta, GitHub, GCP and osquery. They report resolving complex alerts roughly 70% faster, with 20% fewer on-call pages, and their pull requests open in draft mode by default.
The part I'd underline isn't the 70%: they keep several kinds of agent memory deliberately separate, and say that separation is what moved the needle. Somebody decided what the agent should remember, where that knowledge lives and when it gets to see it. That's an architectural choice, not a model capability.
Choice cuts
Smaller plates, same kitchen.
OpenTelemetry Comes to IntelliJ IDEA, GoLand, PyCharm, and WebStorm
The 2026.2 release takes the plugin beyond Rider: logs, metrics, traces and a service map from local runs, inside the IDE, with no backend to stand up. Experimental MCP support exposes get_spans and get_service_map, so a coding agent can read the run it just triggered.
Observability shifting left without anyone having to give a talk about it.
OpenTelemetry Go Logs API and SDK Reach Release Candidate Status
otel/log and otel/sdk/log hit release candidate in v1.47.0-rc.1, the last stop before v1 guarantees make breaking changes impossible, with a bounded-queue BatchProcessor so exporter backpressure stops stalling emission.
The maintainers are explicit that this is the moment to speak up if an API shape doesn't work for you. After that, it's forever.
OpenTelemetry Collector v0.160.0
A new signingprocessor hashes and signs each log record for the emerging OpenTelemetry Audit Logging signal, making tamper-evident telemetry an in-tree concern for the first time. Less fun: dynamic_sampling is renamed adaptive_tail_sampling with no alias, so the old name simply stops working. The README ships a Refinery migration mapping, which tells you who they're expecting.
On running the OpenTelemetry Collector on NixOS and rejoicing in its declarative goodness
Dash0's Michele Mancioppi describes a machine's whole monitoring setup - host and per-process metrics, journald logs, systemd unit health - in the same configuration.nix that describes the machine. Along the way he found that the nixpkgs module only validates your Collector config at build time if you explicitly ask it to, decided that was an oversight, and got the default flipped upstream. It ships in nixos-26.05, and a malformed config then fails nixos-rebuild instead of the Collector's next restart.
He'd normally tell you to keep Collector config in the standard OpenTelemetry YAML, and says so in the post. But NixOS is the exception he'll make, because .nix files are such a pleasure to work with!
If there's one thing I'd take from this fortnight, it's how little of it was about a better model. A taxonomy. An operations manual. A graph. Somebody deciding which memories an agent keeps, which permissions it inherits, and what it leaves behind in the audit trail. Palcuie's superhuman Observe step and his dangerous Orient step ran on the same model; what differed was the system around it. Agentic AI is turning into a platform engineering problem.
Until next time: keep your conventions boring, pour the concrete early, and may your floor hold when the robot arrives.
Kasper, out!
Hi, my name is Kasper!
I'm Kasper Borg Nissen, Director of Developer Relations at Dash0. I'm passionate about Observability and bridging the gap toward developers through Platform Engineering. I've previously worked 8 years as a platform engineer, I'm a former co-chair of KubeCon+CloudNativeCon, and I'm genuinely obsessed with all things cloud-native and open standards.
