This week at a glance
The spine of the week is the cost and observability of running AI in production — and the two are the same problem viewed from different ends. The New Stack put it most directly: observability already has a data problem, and AI is about to make it worse. Observability already runs at 10–30% of infrastructure spend while returning only partial access to the data, which is why every standard coping mechanism is subtractive — sample the traces, index less of the logs, ratchet retention from 30 days to seven to three. Agent workloads make that arithmetic worse, and the survey numbers are stark: 54% of enterprises saw telemetry volume triple in a year, with 43% of the growth coming from AI/ML workloads; average observability spend now sits at $3.17 million and is rising 28% year over year; and 59% of organisations have already terminated or delayed an agentic AI deployment because of monitoring cost. The practical consequence is that telemetry pipelines stop being plumbing and become a budget control: the tier where you decide what is sampled, what is aggregated at the edge, what is routed to cheap object storage and what earns a place in the expensive index. The companion piece on agent traces becoming application data is the other half of the argument — at the 500,000 browser events a day one agent platform reports, a trace of an agent run is no longer a debugging artifact you discard after a week, it is the record of what the system decided and why, which means retention, schema and access control now have product requirements attached rather than just ops ones.
The money story ran in parallel and reached the same place. DevOps.com made the sharpest framing of the week with the observation that an AI coding budget is becoming a variable cloud bill — GitHub Copilot’s mid-2026 move to usage-based billing turned a predictable per-seat licence into a metered credit pool that premium models and agentic features draw down, so two engineers on the same plan now generate very different costs. InfoWorld went after the same total from the other direction, arguing that the biggest hidden AI cost is not GPUs but context bloat — paying to process noise you never filtered out — at a moment when 73% of enterprises say their AI costs have already outpaced what they budgeted. Then the harder question: usage is measurable, value is not. IBM finds only 29% of executives can confidently measure AI ROI and just 25% of AI initiatives deliver the return expected of them. That gap is where Tempo planted its flag this week, launching Workforce Intelligence to tie AI spend to Jira work items — an attempt to make the denominator of the ROI fraction something a delivery organisation already tracks. Whether or not Tempo’s particular join is the right one, the pattern is worth noting: the market is moving from “how many tokens did we burn” to “which unit of delivered work did we burn them on.”
The consolidation story is the third strand, and it is the one with the clearest strategic read. Elastic completed its acquisition of Deductive AI on August 24, on undisclosed terms, folding in an AI SRE agent that forms and tests hypotheses across code, telemetry and organisational knowledge to reach a root cause — CEO Ash Kulkarni’s framing is that engineering teams today are “drowning in telemetry but starved for answers.” The logic is the same logic every observability vendor is now executing against: the differentiator is no longer ingest or storage, it is whether the platform can reason over what it has stored and shorten the distance between a page and an explanation. Grafana Labs supplied the demand-side evidence, telling Business Insider that ARR reached $600M with AI a material driver — more AI systems in production means more signals, more dashboards and more people who need to understand a stack they did not write. And Dynatrace’s State of SRE and Platform Engineering 2026, drawn from 919 senior IT leaders at enterprises above $500M in revenue, found 67% of SREs now name AI model monitoring their top use case. Read the three together and the market thesis is unambiguous — observability is being repriced as the control plane for AI operations, and the vendors are buying, hiring and reporting accordingly.
Beneath all of that, the infrastructure engineering was unusually concrete. NVIDIA documented shadow engine recovery in Dynamo, cutting recovery of a failed inference worker from 283 seconds to 7.3 in its own benchmark — a direct answer to the fact that an inference fleet degrades differently from a stateless web tier, because the expensive state is resident in the accelerator. Google Cloud published two pieces that belong on a platform team’s reading list: best practices for dynamic capacity management, which is what you need when only 17% of IT leaders believe their infrastructure can carry the agent workloads 90% of enterprises intend to deploy within three years, and gVisor sandboxes for distributed Ray clusters on GKE, scaled with Anyscale to 100,000 sandboxes in 17.3 seconds. The New Stack asked why real-time AI at scale is so hard and answered in tail latency rather than throughput — p99 under 10 ms at a concurrency of 300, three seconds at around 740,000 operations per second. Around the edges: DevOps.com on durable execution as the missing runtime for long-running agents, The New Stack on the three roles agents play in a developer platform, Nutanix shipping Enterprise AI 2.8 and an Agent Gateway, neoclouds chasing 20% of a $267 billion AI cloud market by 2030, and Kubernetes 1.37 starting the clock on kube-dns, IPVS and cgroup v1 — the unglamorous maintenance work that decides whether next year’s upgrade is routine or an outage.
This week’s topic map — AI cost management sits at the centre, wired to token economics, hidden costs beyond GPUs, the problem of proving AI value, and Tempo’s attempt to tie spend to delivered work. A telemetry hub connects OpenTelemetry, observability data volume and agent traces as application data; an observability consolidation hub runs from Elastic and Deductive AI through Grafana and Dynatrace into incident AI; an inference and capacity hub ties NVIDIA Dynamo, Google Cloud, neoclouds and real-time serving together; and a platform hub links agent runtimes, gVisor-sandboxed Ray on GKE, Nutanix and the Kubernetes 1.37 deprecations.
View interactive topic map →
Article index
24 articles, grouped by sub-theme. “Weekly News” = this week’s coverage window (August 23–30); “Foundational Reading” = longer-form reference reading on the beat.
Weekly News
Consolidation and the observability data problem
Elastic buys a reasoning layer, Grafana reports what AI demand is doing to its top line, and two pieces explain why the data underneath all of it is getting harder to afford.
Telemetry pipelines and the cost of agent data
Where the spend actually accrues: the pipeline tier that decides what gets kept, the traces agents emit, and two hard looks at what an AI line item does to a budget.
Cost accountability and the compute market
Measuring usage turns out to be the easy half. Proving value, attributing spend to delivered work, and who ends up supplying the compute.
Inference, capacity and real-time serving
The engineering underneath the invoice — recovering lost inference capacity, managing accelerator supply dynamically, sandboxing distributed compute, and why real time stays hard.
Agent runtimes and platform operations
What agents run on, what the developer platform owes them, and the maintenance work that keeps the substrate upgradeable.
Foundational Reading
Token economics and model selection
Three reference reads on the arithmetic behind every architecture decision in this issue: what a token actually costs you, when a smaller model is the correct answer, and how to serve inference sensibly.
Agent authority in practice
The governance read of the week: what happens to delegated authority as an agent runs, and why the principal you granted access to is not always the principal acting.
Detailed write-ups
1. Elastic closes Deductive AI — observability buys the reasoning layer
Business Wire · Business Insider · August 24–26, 2026
Elastic completed its acquisition of Deductive AI on August 24, on undisclosed terms, and what it bought is specific: an AI SRE agent that, in Elastic’s description, “gathers evidence, forms and tests hypotheses, and reasons across code, telemetry, and organizational knowledge to determine root cause,” using reinforcement learning to improve its investigations over time. Elastic CEO Ash Kulkarni gave the rationale in a line — engineering teams are “drowning in telemetry but starved for answers” — and Deductive AI cofounder and former CEO Rakesh Kothari put the same point from the other side, that teams deserve better than hours spent manually tracing a root cause. The stated integration path matters more than either quote: the agent is to be paired with Elastic Observability’s ability to infer entities, relationships and significant operational events from telemetry, which means the reasoning is meant to run over a topology Elastic already derives rather than over raw logs.
The pattern to watch is that observability vendors have stopped competing on how much data they can hold. Storage and ingest are commoditising, the cost curve on both is under active downward pressure from customers, and no buyer in 2026 is choosing a platform because it can index more. The competition has moved to time-to-explanation — the distance between a page firing and an engineer understanding why. That is a reasoning problem, which is why acquisitions in this category now look like AI acquisitions rather than infrastructure ones. The reinforcement-learning detail is the part to press a vendor on at renewal: a system that learns from investigations is only as good as the corpus it learns from, so the useful question is whether the capability is grounded in your topology, change history and past incidents, or whether it is a generic model reading your logs with a confident tone.
Grafana Labs supplied the demand-side evidence in the same week, with CEO Raj Dutt telling Business Insider that annual recurring revenue has reached $600M, with AI a material driver of the growth. That direction of causation is worth stating plainly, because it is the commercial case for everything else in this issue: more AI in production means more services, more signals, more non-determinism and more people trying to understand a system they did not write. Observability spend is rising as a direct function of AI adoption. If your organisation is budgeting AI programmes without a corresponding line for the telemetry needed to operate them, the number is wrong, and this week’s consolidation news is the market telling you so.
Sources: Business Wire (Elastic completes Deductive AI acquisition) · Business Insider (Grafana ARR hits $600M)
2. Observability has a data problem, and telemetry pipelines are the answer on offer
The New Stack · August 25–26, 2026
The New Stack’s framing is the one to carry into your next capacity conversation: observability already has a data problem, and AI is about to make it worse. Will Kelly builds the case around Bronto, a Dublin data-observability startup whose co-CEOs Trevor Parsons and Noel Ruane argue that OpenTelemetry settled the collection question and left the storage question wide open — the company’s head of community, Severin Neumann, is himself an OpenTelemetry maintainer. The numbers are the useful part: observability now consumes 10–30% of infrastructure spend and still returns only partial access to the data, which is why every standard response is subtractive — sample the traces, index less of the logs, ratchet retention from 30 days to seven to three, and rehydrate from cold storage when an incident demands it. Bronto’s own answer is a polymorphic datastore, BrontoDB, which it claims holds 100x more observability data than incumbents such as Datadog at twelve-month full-fidelity retention with sub-second search. Treat the multiple as a vendor claim; treat the diagnosis as sound, because agentic systems emit more steps and higher cardinality per unit of user-visible work than the request-response services they sit beside.
The companion piece — Megan Carnegie’s, sponsored by Apica — is the practical response, and its survey figures are the sharpest cost evidence of the week. 54% of enterprises saw telemetry volume triple over the past year, 43% of that growth came from AI/ML workloads, average observability spending sits at $3.17 million and is growing 28% year over year, and respondents expect a 9.5x increase in telemetry data within two years, with 44% bracing for somewhere between 6x and 100x. The finding that should change a roadmap conversation is this one: 59% of organisations have already terminated or delayed an agentic AI deployment because of monitoring costs. That decision is being made in finance, not engineering. Apica CPTO Andi Mann makes the pipeline-first case, and the mechanics are vendor-neutral even where the framing is not — sample repetitive successful events while retaining every failure; enrich records with agent, session, model, tool, token and cost attributes so spend can be attributed at all; redact sensitive prompts and identifiers before they land; and aggregate metrics to destinations with different cost and retention profiles. The claimed payoff (40% lower total cost of ownership, and pipeline-mature organisations 80% more likely to avoid operational cost problems) is Apica’s. The structural point is yours to keep: a pipeline is a vendor-independent place to make these decisions, which is also what makes an observability contract renegotiable.
The third piece is the one most teams have not internalised yet, and Manveer Chawla — Zenith cofounder, previously a director of engineering at Confluent — states it plainly: for many agentic products the execution record “turns out to be application data with a telemetry-shaped workload.” The volumes are why. Laminar reports more than 500,000 browser events per day, and a single browser-agent session running thirty minutes or more can generate hundreds of thousands of DOM diff events — a shape Postgres handles badly the moment users start asking for complete task histories and cross-run analysis, which is why the piece traces the migration towards an analytical store such as ClickHouse, with the OpenTelemetry GenAI semantic conventions and tools like Langfuse supplying the schema vocabulary. The consequence is not really a storage decision, it is a classification one: an agent trace records which tools were called, what context was retrieved and what was executed on a user’s behalf, which makes it evidence in a dispute, an audit or a post-incident review of an automated action. That pulls retention, schema stability and access control out of ops and into legal and product. The cheap move this quarter is to decide deliberately which spans are ephemeral telemetry and which are records, and route them differently in the pipeline from the start.
Sources: The New Stack (observability has a data problem) · The New Stack (telemetry pipelines and agent costs) · The New Stack (when agent traces become application data)
3. The AI line item goes variable, and nobody can prove the return yet
DevOps.com · InfoWorld · SiliconANGLE · August 24–26, 2026
DevOps.com’s Carla Castillo named the structural change cleanly: AI coding spend now behaves more like cloud infrastructure than SaaS. The concrete trigger is GitHub Copilot’s move to usage-based billing in mid-2026, pricing premium usage against a metered pool of credits that premium models and agentic features draw down — which means, as the piece puts it, that two engineers on the same plan can generate very different costs, with surprises measured in tens of dollars per user per month. Engineering leaders who spent a decade learning to forecast tooling spend are now holding a line item that behaves like egress. Castillo’s four metrics are the minimum instrumentation: cost per developer across all tools, utilisation (active versus assigned seats), premium-model usage share, and forecast versus budget. If your finance partner is still carrying AI tooling as a fixed cost, that is a conversation to have before the next quarter closes rather than after.
InfoWorld attacked the same total from the other side, and its answer is more specific than the headline suggests. Joseph Morais argues the biggest hidden AI cost is not GPUs but context size and data quality: “if you’re not preparing and slimming down the data that feeds into a model’s context, you’re merely paying to process noise.” With 73% of enterprises reporting that their AI costs have already outpaced what they budgeted, that is the cheapest lever most teams have not pulled, because it sits upstream of everything else in this issue — a bloated context inflates token spend, inference latency and the telemetry emitted per call simultaneously. The prescription is unglamorous and familiar to anyone who has run a streaming platform: filter and shape data before it reaches the model, using stream processing (Apache Flink is the worked example), and enforce data contracts through schema validation so the filtering does not silently rot. The author writes from Confluent, so the tooling choice is not neutral — but the underlying correction holds. A cost model denominated in GPU hours alone will underestimate, and it will point optimisation effort at the one component you probably cannot change.
Which sets up the week’s hardest question, also from InfoWorld: enterprises can measure AI usage, but proving it delivered value remains largely unsolved. Taryn Plumb stacks the evidence — IBM finds only 29% of executives can confidently measure AI ROI and just 25% of AI initiatives deliver the return expected, while Kyndryl reports 61% of senior business leaders feel more burdened to prove AI ROI than they did a year ago. Tempo CEO Vic Chynoweth says the quiet part out loud: “The amount of money people are spending on AI is enormous, and a very large percentage of it is wasted.” His company’s answer, launched this week as Workforce Intelligence on the Atlassian Marketplace, correlates inference API telemetry from tools such as GitHub Copilot, OpenAI Codex and Claude Code with human effort data, attaching cost and performance figures to individual Jira issues; CTO Shams Chauthani’s claim is that it “correlates the session to the commit directly, so the answer is verifiable.” Tempo has tracked human-delivered work in Jira since 2007 and counts 30,000-plus customers including Cisco, Airbus and Oracle, which is the real asset: the denominator already exists. The join is imperfect — ticket-level attribution inherits every flaw in your ticket hygiene and misses AI-assisted work that never became an issue — but the pressure behind it is real, with Forrester finding fewer than a third of decision-makers can tie AI value to financial growth and expecting enterprises to defer a quarter of planned AI spending into 2027. If you take one action from this cluster, make it this: pick a unit of delivered work your organisation already counts, and start attributing AI spend to it now, imperfectly, rather than waiting for a measurement framework that will not arrive.
Sources: DevOps.com (AI coding budget as a variable cloud bill) · InfoWorld (your biggest hidden AI cost isn’t GPUs) · InfoWorld (measuring AI usage vs proving value) · SiliconANGLE (Tempo Workforce Intelligence)
4. Serving the load: shadow-engine recovery, dynamic capacity, and the limits of real time
NVIDIA Technical Blog · Google Cloud Blog · The New Stack · InfoWorld · August 23–26, 2026
NVIDIA published the most operationally specific piece of the week, and the headline number is the whole argument: in its own benchmark, restoring a failed inference worker took 283 seconds by cold restart and 7.3 seconds with shadow engine recovery in Dynamo — roughly a 39x improvement. The mechanism explains why inference recovery is slow to begin with. A shadow engine sits fully initialised but idle on the same GPUs as the active engine, and a per-GPU sidecar called the GPU Memory Service, built on the CUDA Virtual Memory Management API, lets both engines share a single copy of the weights instead of duplicating them in HBM; engine election is arbitrated with a POSIX flock, and NCCL communicators and captured CUDA graphs are preserved rather than rebuilt. Recovery becomes a handoff instead of a rebuild, and the tail behaviour shows it: across the post-fault window, p50 time-to-first-token was 1,311 ms, decode held at 46 tokens/s/user, and just 1 of 398 requests exceeded a five-second TTFT. The rig was two workers serving GLM-5.2 quantised to NVFP4 on NVIDIA B200 nodes at TP=8 with a 200K maximum context and FP8 KV cache, driven at 0.7 requests per second with 32,000 input and 1,000 output tokens per request. Two constraints before you plan around it: the feature is a preview, and it requires Kubernetes 1.34 or newer with DRA enabled and the NVIDIA GPU DRA driver installed, with vLLM as the primary supported backend. The lesson generalises past Dynamo: capacity planning for inference belongs in units of time to restore serving capacity, not replica count, and if you have never measured that number on your own stack it is the single most useful experiment on this list.
Google Cloud’s Drew Bradstock, senior director of product for orchestration and Kubernetes, supplied the planning-side companion and opened with the gap that motivates it: 90% of enterprises want to deploy agents within the next three years, while only 17% of IT leaders are confident their current IT setup can handle the load. The post is essentially a catalogue of consumption modes and when each applies — Dynamic Workload Scheduler in calendar mode for capacity you can book against a known date, flex-start for jobs that can wait for a window, Spot VMs for work that can be displaced, and committed use discounts for the predictable floor, with compute flexible CUDs quoted at up to 63% off. On the scheduling side it points at GKE custom ComputeClasses and dynamic resource allocation so that fallback priority is expressed in the cluster rather than in a runbook, with managed instance groups, instance flexibility and bulk VM creation underneath. The useful reframe is treating accelerator capacity as a portfolio with an explicit displacement policy rather than as a single autoscaling decision — anyone who has watched a batch evaluation starve an interactive endpoint at the wrong moment will recognise the failure mode it is trying to prevent.
The other two pieces set the boundaries. ScyllaDB’s Felipe Cardeneti Mendes asks why real-time AI at scale is so hard and answers with measurements rather than adjectives: a system holding p99 under 10 ms at a concurrency of 300 degraded to a three-second p99 at around 740,000 operations per second, and vector-index mutations under load dropped recall to 42% while serving roughly 150,000 approximate-nearest-neighbour queries per second. The model did not change; the answers got worse anyway. His line is the one to quote in design review — “Tail latency isn’t a bug that you can fix, it’s a property of your architecture” — and the prescriptions follow from it: isolate training from serving, index vectors asynchronously, and monitor feature freshness and index health as first-class signals rather than afterthoughts. Adding accelerators does not fix a variance problem. InfoWorld’s Bill Doerrfeld frames the market around all of it: neocloud revenue passed $25 billion in 2025, and Gartner senior principal analyst Hardeep Singh expects the specialists — CoreWeave, Lambda, Nebius, RunPod, Vultr — to take about 20% of a $267 billion AI cloud market by 2030. The concentration risk is the part a platform team should read twice: Microsoft accounted for 67% of CoreWeave’s 2025 revenue, and CoreWeave is committing roughly $30 billion of capex in 2026 against that customer base. The article lands on coexistence — neoclouds taking frontier training, hyperscalers keeping the broader enterprise estate — which for you means optionality: if your inference stack only runs on one provider’s scheduler, you have no leverage whichever way it settles.
Sources: NVIDIA (shadow engine recovery in Dynamo) · Google Cloud (dynamic capacity management) · The New Stack (why real-time AI at scale is so hard) · InfoWorld (can neoclouds corner AI compute?)
5. Where agents actually run: the missing runtime, the sandbox, and the platform’s job
DevOps.com · Google Cloud Blog · The New Stack · Blocks & Files · August 25–29, 2026
DevOps.com’s Anuj Kapoor made the case that long-running AI agents have no proper runtime, and the framing is sharper than “agents need state”. The execution models we have assume either a request that finishes in seconds holding nothing, or a batch job that runs to completion and dies; an agent working a task across hours, external dependencies and human decisions is neither, and plain HTTP request/response is the specific abstraction he names as the wrong shape. His list of what such a runtime must provide is a serviceable checklist to run your own setup against: “state, retries, checkpoints and recovery”, the ability to “coordinate multi-step workflows, survive failures, pause for human review and resume reliably”, and around all of it observability, correlation identifiers, retry policies, cost controls, security boundaries and careful versioning. His proposed answer is durable workflow orchestration, worked through Azure Durable Functions and Azure AI Foundry — the pattern generalises to any durable-execution engine, and the discipline worth adopting is to write down which of those properties your current assembly of queues, workflow engines and databases actually delivers today.
Google Cloud and Anyscale published the security half of the same problem jointly — Google staff software engineer Andrew Sy Kim with Anyscale CTO Philipp Moritz — and the number they lead with is the reason to pay attention: Ray on GKE scaled to 100,000 gVisor sandboxes in 17.3 seconds across thousands of nodes. The API arrived in Ray 2.58 as ray.experimental.sandbox: create an environment from an OCI image with explicit CPU and memory limits, execute commands inside it, move files in and out, inspect its state, tear it down. gVisor’s user-space kernel gives a materially smaller attack surface than container isolation alone, with sub-second sandbox startup and low per-sandbox memory overhead, and critically it does not require exposing a Docker daemon or the host Docker socket — which is precisely how most home-grown code-execution sandboxes end up leaking. Ray is where a great deal of distributed AI work already runs, and increasingly what runs on it is code a model wrote; Kata Containers support is signposted as future work. If you are executing agent-generated or customer-supplied code anywhere near your data, this is the shape of the answer.
The New Stack contributed the platform-side piece. Port’s Matar Peles sets out three roles agents play in a developer platform — “AI agents as platform consumers”, “AI agents as internal platform components”, and “AI as a resource with its own lifecycle”, which she labels AgenticOps — a genuinely useful taxonomy for arguing about scope, because the governance an agent needs when it reads context differs sharply from what it needs when it is provisioned as a managed resource; she notes 47% of organisations surveyed in early 2026 asked for agent and skill registries, which is the registry problem arriving on schedule. Nutanix, meanwhile, shipped the enterprise-infrastructure version of the same bet: Nutanix Enterprise AI 2.8 and Service Provider Central generally available, Nutanix Kubernetes Platform 2.19 arriving shortly, plus Nutanix Agent Gateway and Nutanix Private Inference, with NVIDIA AI Enterprise integration and Kubeflow, Milvus and Slurm in the applications catalogue; speculative decoding is claimed to accelerate token generation up to 2.5x, and parameter-efficient fine-tuning is supported for models under 8B parameters. EVP of product management Thomas Cornely put the strategy in one sentence: “Enterprise AI should not require customers to rebuild the systems that already run their business.” The through-line across all four is that the platform layer is being redefined around agents this year, and the teams that write down what their platform guarantees an agent will get — state, identity, isolation, observability — will have a much easier time than the ones discovering the gaps one incident at a time.
Sources: DevOps.com (the missing runtime for long-running AI agents) · Google Cloud (gVisor sandboxes for distributed Ray clusters) · The New Stack (the 3 roles AI agents play in your developer platform) · Blocks & Files (Nutanix agentic AI)
6. Automated diagnosis is not automated understanding
DevOps.com · Dynatrace · The Register · August 25–26, 2026
The best-titled piece of the week is also the most important for anyone shipping incident AI, and Jyostna Seelam’s central assertion fits in four words: “Correlation is not diagnosis.” Her argument is that most AI incident tools group related alerts and present the grouping as a cause — “grouping related symptoms isn’t the same thing as identifying a cause” — because “finding symptoms is easy; understanding causes is not”. Postmortem practice has spent two decades learning that the first plausible cause is usually not the whole cause, and that a confident wrong answer costs more than no answer at all: it is trusted early, is wrong once expensively, and is then ignored permanently. Four requirements fall out of the piece and together they make a serviceable vendor scorecard — test causal direction against a dependency graph rather than inferring it from co-occurrence; match the incident against incident history; communicate uncertainty instead of guessing confidently; and work from live dependency data rather than an architecture diagram that stopped being true two quarters ago. Her single best evaluation question is one to put to every root-cause feature arriving through acquisition, Elastic’s included: “Does this tool group related alerts, or does it actually explain why one caused another?”
Dynatrace’s State of SRE and Platform Engineering 2026 supplies the organisational context, and the sample is solid enough to argue with: 919 senior IT leaders at enterprises above $500M in annual revenue across the Americas, EMEA and Asia-Pacific, surveyed between October 2025 and January 2026. The headline shift is that 67% of SREs now name AI model monitoring their top use case and 50% already use AI-powered capabilities for automated incident response — SRE has become an AI-operations function faster than most job descriptions have caught up. The strain shows in the supporting numbers: nearly half of SRE respondents say too many data sources and metrics hinder their ability to define and manage effective SLOs, only 40% of platform engineers embed observability across all deployment stages, and 37% name integrating with existing tools their top challenge — this despite 89% of organisations practising platform engineering having implemented an internal developer platform and 92% reporting executive support. Chief product officer Steve Tack frames the required response as a move “from managing systems to orchestrating them, connecting observability, automation, and agentic AI”. Read it against your own team, because the failure most organisations are heading for is a staffing and ownership one rather than a technology gap: AI services get shipped by teams that do not run them, and the operational load lands somewhere unplanned.
The week’s reminder that the substrate still needs tending came from The Register: Kubernetes 1.37, nicknamed Garhwal, landed on August 26 with 67 changes and a clear-out of three pieces of legacy. The timelines matter more than the headline. kube-dns is being retired in favour of CoreDNS — the default since v1.13 — and anything still on it must move before 1.40. The IPVS mode of kube-proxy is deprecated with removal signposted from 1.43 and nftables as the replacement, so anyone who tuned kube-proxy for scale years ago and never revisited it now has a migration to schedule. cgroup v1 bites hardest, because it is a node-operating-system problem rather than a cluster one: since 1.35, nodes relying on it will not initialise at all, which makes it a fleet-wide OS upgrade rather than a cluster-level change. On the additive side, the metrics.k8s.io Metrics API finally graduated to GA after nine years in beta, with release lead Dipesh Rawat noting it had been “widely used in production for years” regardless of the label. The practical step is small and worth doing now: audit your clusters for all three before you plan the upgrade, not during it. The clusters most likely to be affected are the oldest and least-touched — which, in a year when AI workloads are being scheduled onto whatever capacity exists, are increasingly the ones running something that matters.
Sources: DevOps.com (automated diagnosis isn’t automated understanding) · Dynatrace (State of SRE and Platform Engineering 2026) · The Register (Kubernetes 1.37 removes kube-dns, IPVS and cgroup v1)
7. Foundational: what a token really costs, when a smaller model wins, and the comprehension you traded away
O’Reilly Radar · InfoWorld · August 19–28, 2026
Tokens Aren’t Dollars, by Tim O’Brien, is the reference read behind every cost story in this issue, and its argument is narrower and more useful than the title suggests: counting tokens is necessary, but a token is not a unit of value, and tokens are not interchangeable across models or use cases. The same nominal volume can be cheap and productive on one model and an expensive mistake on another, which makes cross-model comparison by token count actively misleading — and none of it captures the retrieval, orchestration and human-review work wrapped around the call. His worked cases are all about mismatch rather than volume: spending hundreds of dollars a day on a task with no way to judge whether that is waste, or running a billion tokens through a frontier model for work a cheaper one would have finished. Read it alongside the Tempo launch and the pattern is consistent — the industry is groping towards a denominator, and per-token accounting is not it.
When Smaller Models Win, by Sruly Rosenblat, is the architectural counterpart and the highest-leverage lever most teams have not pulled. The examples are concrete rather than rhetorical: a 4B-parameter research model, LiteResearcher, is reported to have beaten Claude Sonnet 4.5 on some search benchmarks; the Docling family does document extraction at as little as 258 million parameters; and a 4B negotiation model outperformed frontier GPT-5-series models on social negotiation tasks. The author’s own 15M-parameter chess model predicted a human’s next move with 27% accuracy — a reminder that task-shaped models buy cheaply what general-purpose ones spend heavily to approximate, with LoRA making the fine-tuning cheap enough to be worth an experiment. The discipline implied is to profile by step rather than by application: classification, extraction, routing and the intermediate hops of an agent chain rarely need frontier reasoning, and they usually arrive there by default rather than by decision. InfoWorld’s Isaac Sacolick covers the serving side with five practices — architect for integration and performance, secure the AI’s data and actions, separate training and inference requirements, design for flexible and resilient operations, and optimise for costs and changing AI models — and lands two numbers worth carrying into planning: only 25% of organisations have moved 40% or more of their AI experiments into production, and a multi-agent system can consume 15 times as many tokens as a single chat interaction. That multiplier is the argument for step-level model selection restated as arithmetic.
The fourth read is the governance one, and it is not the identity paper its title suggests. Principal Drift in Practice, by Shreshta Shyamsundar, is about cognitive debt — the widening gap between how complex a system has become and how well the team that owns it still understands it — and the loss of control that follows when an organisation ships code it can no longer reason about. Her claim is that the 2024–2025 preference for speed over comprehension has surfaced in 2026 as tripled production incident rates and as architectural decisions nobody on the team is equipped to make. The mitigations are process rather than tooling, and they are implementable next sprint: route code review by tier, reserving full line-by-line review for security, money movement and data integrity while decoupled changes and utilities get a systems-level inspection; never let the agent that authored a change be its sole reviewer; and use literate code explanations with comprehension checkpoints so understanding is demonstrated rather than assumed. To make it stick she wants executive sponsorship, a written tier-assessment policy, CI/CD enforcement, and postmortems that check whether the tier was assigned correctly in the first place. For anyone operating AI in production this is the read that connects to everything else in the issue: an incident AI you cannot second-guess, an agent runtime you did not design and a telemetry pipeline you inherited are the same debt wearing different clothes.
Sources: O’Reilly Radar (Tokens Aren’t Dollars) · O’Reilly Radar (When Smaller Models Win) · InfoWorld (AI inference: 5 best practices) · O’Reilly Radar (Principal Drift in Practice)
Calls to action
- Put your AI tooling spend on the same footing as cloud spend. It is now a variable bill, not a per-seat licence. Give it per-team attribution, a budget with an alert threshold, a named owner and a monthly review — and do it before the next quarter closes rather than after the first spike.
- Build the cost model on more than GPU hours. InfoWorld’s answer to where the money actually goes is context size and data quality — if you are not preparing and slimming the data that feeds the context window, you are paying to process noise. Audit your prompt and retrieval payload sizes before you go shopping for cheaper compute; a GPU-denominated model will underestimate and will point your optimisation effort at the wrong thing.
- Pick a denominator for AI value this quarter, imperfectly. Usage telemetry is abundant and is not value. Attribute spend to a unit of delivered work your organisation already counts — tickets, merged changes, closed incidents — and accept that version one will be wrong. It is still more defensible than a productivity percentage with nothing underneath it.
- Treat the telemetry pipeline as a cost-control tier. Tail-based sampling, edge aggregation, routing audit-grade data to object storage and only the hot subset to the expensive index, and redaction of agent inputs and outputs. It also gives you a vendor-independent place to make those decisions, which is what makes an observability renewal negotiable.
- Classify agent traces as records, not just telemetry. Decide now which spans are ephemeral debugging data and which are the evidence of what an automated system decided on a customer’s behalf — then give the second group a stable schema, a legally-set retention period and access controls to match, and route them separately.
- Measure your time to restore inference capacity. An inference replica is not a stateless web replica; the expensive part is loaded weights and warm cache. NVIDIA’s shadow-engine work exists because that recovery is slow. Run the experiment on your own stack and put the number in your capacity plan.
- Audit for kube-dns, IPVS proxy mode and cgroup v1 before planning the 1.37 upgrade. All three are gone in Kubernetes 1.37, and cgroup v1 removal is a node-OS problem rather than a cluster one. The clusters most likely to be affected are the oldest and least-touched — which is increasingly where spare capacity for AI workloads is being found.
- Profile your workload by step and move the defaults. Classification, extraction, routing and intermediate agent steps rarely need a frontier model. Measure which calls genuinely require frontier reasoning rather than assuming the application-level answer, then change the routing defaults for everything else.
On our watch list
- Whether observability consolidation delivers reasoning or just packaging. Elastic has bought Deductive AI’s root-cause capability. Watch whether the integrated product can ground its explanations in customer-specific topology and change history, or whether it degrades into a generic model reading logs with a confident tone — the difference determines whether the whole acquisition wave was worth it.
- Observability spend as a fixed percentage of AI spend. Grafana’s $600M ARR on AI-driven demand suggests a ratio is forming. Watch whether organisations start budgeting telemetry as an explicit fraction of every AI programme, or keep discovering the cost after the workload is already in production.
- A real runtime for long-running agents. Durable state, pause-and-resume without holding compute, checkpointed recovery and persistent identity across a multi-hour run. Everyone is currently assembling this from workflow engines and queues. Watch for the first credible product category, and for whether the hyperscalers or the workflow vendors get there first.
- Attribution models for AI value. Tempo’s Jira join is one attempt; it will not be the only one. Watch which unit of work the market settles on — tickets, merged changes, resolved incidents, customer outcomes — because whatever wins will shape how AI programmes are funded for the next several years.
- Calibrated uncertainty in incident AI. The postmortem argument is that a confident wrong diagnosis is worse than none. Watch whether vendors start shipping confidence signals and evidence trails alongside root-cause conclusions, or whether the first wave of incident AI burns its credibility the way early anomaly detection did.
- Sandboxing becoming the default for agent-generated code. gVisor on distributed Ray clusters is a strong pattern. Watch whether user-space kernel isolation becomes the expected posture for running model-written code, or whether teams keep relying on container boundaries that were never designed for unreviewed code.
- Cognitive debt showing up in a named incident. The argument that teams are shipping systems they no longer understand — and that this is behind tripled production incident rates — is still an argument rather than a case file. Watch for the first well-documented postmortem that names comprehension rather than tooling as the root cause, because that is what will move tier-based review and builder/reviewer separation from a good idea to a control someone has to sign off on.
- Whether neoclouds hold their position as inference outgrows training. The specialist bet is that AI-native economics beat general-purpose cloud; the hyperscaler bet is data gravity and integration. Watch pricing, capacity availability and whether serious workloads start running multi-provider by design rather than by accident.
|