The software that writes itself is learning to fix itself too — and it just got X-ray vision into where code bleeds money.
The Summary
- NYC startup Dash0 acquired Berlin's Polar Signals to integrate continuous profiling — tech that shows exactly which lines of code consume computing power and memory in real time
- The strategic play: feed granular performance data directly to AI agents that can monitor and optimize running software autonomously
- Dash0 is building "Agent0" with an "AutoTune" feature, turning observability platforms from dashboards humans read into control systems AI agents act on
The Signal
Dash0 isn't buying Polar Signals for its customer list. It's buying a pipeline into the operational guts of running software — the kind of high-resolution data that turns an AI agent from a code generator into an autonomous performance engineer.
Continuous profiling tracks where software spends CPU cycles and memory at the function level, often down to individual lines. When an application slows or costs spike, you don't just know something is wrong. You know which function in which service is eating resources, why, and often how much that inefficiency costs per hour. This precision matters acutely in AI infrastructure, where inference workloads can burn thousands in compute before a human notices.
Traditional observability platforms show you the problem. Dash0's Agent0, fed by Polar Signals' profiling data, is designed to solve it. The company is building what it calls "agentic capabilities" — AI systems that don't just flag performance bottlenecks but rewrite configurations, tune parameters, or refactor code segments while software runs in production. AutoTune, their first feature in this direction, will let agents optimize applications without human intervention.
"AI agents not only write software but also monitor and improve it while it is running."
This is the Web4 stack emerging in real time:
- Agents write the code (Cursor, Replit, Devin)
- Agents deploy the code (infrastructure-as-code tooling, CI/CD automation)
- Agents now tune the code live (Dash0's Agent0 plus Polar Signals profiling)
The next capability gap to close: agents deciding what to build based on user behavior and business metrics. That's when software stops needing product managers for incremental optimization. We're not there yet, but Dash0 is building toward a world where the build-deploy-monitor-optimize loop runs with minimal human touch.
The Berlin angle matters too. Polar Signals represents Europe's quiet strength in infrastructure tooling — deep technical capabilities without the Valley hype cycle. Dash0, despite being NYC-based, is pulling that engineering DNA into its platform. Continuous profiling isn't sexy. It's also non-optional for anyone running agents that modify production systems. You can't let AI change live code unless you can measure the impact of every change at millisecond resolution.
The Implication
If you're building AI agents that touch production infrastructure, observability isn't a dashboard problem anymore. It's an API problem. Your agents need structured, real-time access to performance data to make autonomous decisions. Dash0's bet is that continuous profiling becomes the sensory layer for self-optimizing software.
For engineering teams, this shifts the job again. Less time monitoring dashboards and writing optimization patches. More time setting constraints, defining cost thresholds, and teaching agents what "better" means in your context. The work moves up the stack, from solving problems to defining what problems agents should solve and how much latitude they get.