The MCP observer sat between the agent and its tools like a court stenographer between the lawyer and the witness. It heard everything. It recorded everything. It understood the shape of the conversation without participating in it.
Jay had been studying the observer's output for three days. Not because anything was wrong—everything was working perfectly. He was studying it because the data was fascinating in a way that raw syscall traces weren't. Syscall traces told you what the machine did. MCP traces told you what the agent intended to do.
Every tool call was an intention made manifest. When the agent called the file-read tool, it was saying: I want to understand this code. When it called the file-write tool, it was saying: I believe this change is correct. When it called the test-runner tool, it was saying: I want to verify my belief. The MCP observer captured each of these intentions, timestamped them, and correlated them with the filesystem and network telemetry that Leash was already collecting.
The result was a three-dimensional record of agent behavior. Layer one: what the agent asked to do (MCP tool calls). Layer two: what the system actually did (syscall traces). Layer three: what crossed the network boundary (connection logs). Each layer validated the others. If the agent called a file-write tool but no corresponding write() syscall appeared, something was wrong. If a network connection appeared without a corresponding MCP tool call, something was very wrong.
"The correlation is the killer feature," Jay told Navan during their afternoon coffee walk. "Any one layer is useful by itself. But when you can cross-reference tool intentions with system behavior and network activity, you get a complete picture. No gaps. No blind spots."
Navan nodded. He'd been building dashboards for the correlated data, pulling MCP events and syscall events onto the same timeline in the Control UI. The visualization showed tool calls as tall bars in one color and the resulting syscall activity as smaller bars beneath them in another color, like a musical score where the melody line was tool-level intent and the harmony was system-level reality.
"It's an audit trail that actually tells a story," Navan said. "Most audit logs are just noise. This one has narrative structure."
He was right. Each Leash session produced a log that read like a chapter. The agent started by reading files (exposition). It formed a plan (rising action). It made changes (climax). It ran tests (denouement). And every beat of that narrative was captured at every level of abstraction, from the high-level tool call down to the individual syscall.
Justin reviewed the correlation engine that weekend. He didn't comment on the code. He commented on the architecture. "This is what observability looks like when you're observing something that thinks," he wrote in the design doc. "Or at least something that acts like it thinks."
The MCP observer kept listening. The stenographer never sleeps.
The three-layer model—intention, execution, network—is such a clean way to think about agent observability. And the musical score visualization metaphor is gorgeous.