vision
TLDR; Logs were built for humans to read. The reader is becoming the agent, and the observability stack has to be rebuilt for it. We start with logs, and we serve agents first.
For forty years, every log was written to be read by a person.
It started with syslog. In the early 1980s, Eric Allman needed to see what Sendmail was doing, so he had it write lines to a file. There was no standard. It just spread, machine to machine, until it became the way software talked about itself. A log was a story a program told a human, one line at a time. For a while, a human could keep up.
Then one machine became many. A monolith became a hundred services, and the output grew past what any person could read. So we built tools to look harder. Centralized logging, to pull it all into one place. Search, to find the line you already suspected. In 2010, Google's Dapper paper gave us distributed tracing, a way to follow one request as it threaded through dozens of services. By 2019 that became OpenTelemetry, and the field borrowed a word from control theory: observability, Rudolf Kalman's idea that you can infer the inside of a system from its outputs. Logs, metrics, traces. Three pillars.
Every one of those advances answered the same question. How does a human make sense of more output than a human can read? The dashboard is the monument to that question. It is a beautiful, elaborate apology for the fact that nobody can read the logs anymore.
And the volume kept winning. One microservice now emits millions of lines a day. A real incident spans the whole fleet at once. Most platform work is still a person at a terminal at 3am, running kubectl against one pod at a time, scrolling, guessing, paging the next person when they run out of guesses.
Debugging runs through an agent now. Claude Code, Codex, whatever you point at the incident. And the agent inherits a stack built for eyes it does not have. It cannot glance at a dashboard. It cannot scroll forever. Its memory is finite and it pays by the token. So we hand it the same firehose we could never read ourselves, and we watch it do what we did: take a thin slice, miss the line that mattered, run out of room.
The infrastructure was built for the wrong reader.
This is the start of an era, not an edge case.
Agents become the primary consumer of logs, and soon the primary producer of them.
Systems watched and operated by other systems. When that happens, the bottleneck is no longer human attention. It is whether an agent can actually read what the world emits.
So we are building for that reader, from the data up. Codag turns infrastructure logs into something an agent can hold and reason over. Compact, structured, and cited back to the exact lines that matter, at the scale real systems produce. Not a dashboard for a person to squint at. A capsule an agent can consume.
We start with logs, because that is where agents drown first. It does not end there. The same gap runs through metrics, traces, configs, and the live state of a system itself. Anywhere an agent has to understand infrastructure through more output than it can hold, we intend to be the layer underneath.
We serve agents first. That is the whole bet.
No one will miss debugging systems by hand. The 3am scroll, the dashboard archaeology, the pod-by-pod kubectl: it becomes history, the way reading raw syslog off a single box did. We are building the infrastructure that lets agents understand and operate distributed systems at scale, so the people who used to do it by hand can go build something better.
Michael ZhouFounder, Codag