ariadne

Overview

Ariadne is a desktop app I built to inspect AI coding sessions after the work is done. It is not another chat client. The point is to look at the trail left behind: sessions, tool calls, file activity, model changes, cost, knowledge usage, and the overall shape of what happened.

Right now it is mostly centered on pi sessions. It reads the logs and artifacts that already exist, then turns them into views that are easier to inspect, replay, and think about.

I built it because I kept coming back to one question: what did the agent actually do?

What it does

• Overview: top-level stats, trends, and activity heatmaps
• Usage: cost, tools, patterns, and file hotspots across projects or within one scoped project
• Sessions: browse runs, then drill into replay, traces, and exploration views
• Session detail: inspect a single run with much more fidelity than a flat transcript
• QMD: surface the knowledge-work side of sessions too

Why this exists

Ariadne came out of a shift in how I think about this whole space. I do not just want better ways to prompt models. I want better ways to inspect the work afterwards.

One of the claims behind the project is that your codebase is the agent's memory. Agents are stateless. Every session starts cold. The main thing that persists across sessions is the codebase itself. So the codebase is not just the thing agents work on. It is also the thing they think with. File structure becomes navigation. Code patterns become instructions. Architecture becomes the mental model they inherit.

That is part of why session analysis matters to me. If agents are shaped by the environments they enter, then looking at sessions is one way to study the interaction between model behavior and codebase design.

As usage goes up, the problem is not only generation. It is visibility. Sessions branch. Tools run constantly. Files get touched unevenly. Knowledge systems get used in ways that are hard to reconstruct later. Ariadne is my attempt to make that activity easier to read.

How it works

Ariadne is an Electron desktop app with a TS codebase e2e. Every time the app opens, it reads and parses the sessions into its current local view. If I want the latest state, I need to hit sync again. That makes it slower and less reactive than a normal product, but that is intentional. I am not designing it like a live dashboard. It is a personal local tool, so I care more about being able to inspect the data than making every interaction feel instant.

The stack is mostly there to keep everything local and fast enough to experiment with. That is also why I haven't yet added any type of storage.

Open questions

This project is still active because I do not think the interesting questions are settled yet.

• How does an agent actually behave inside a given codebase?
• What should happen to old sessions once they are no longer operationally useful?
• Can old sessions be processed into something more valuable than an archive?
• What signals matter beyond cost, tokens, tools, and touched files?
• Does better visualization actually help, or does it just look nice?

Status

Ariadne is a proof of concept. It is a basic setup to build on top of, not a finished system. It is also mostly vibe coded and, honestly, mostly AI slop.

I built it mostly to see if I could answer some of my own questions and give myself an area to experiment in. Because of that, it is biased toward my own setup, especially the way I use my agents repo and related local tooling. I am not really trying to turn it into a product. Right now it is more a reflection of how I think and what I am interested in.

I am opening it up because I think there is something here worth pursuing. My guess is that the best way to approach it is to fork it or clone it locally and see how it behaves against your own setup.

Screenshots

These are screenshots from different pages of the app that I built to explore the idea and see whether this way of looking at sessions actually makes sense.

Usage

This is where I start looking for patterns instead of individual runs.

Sessions

The sessions page gives me a way to browse runs, see what happened recently, and pick the thing I want to inspect more closely.

Session detail

This is where I inspect replay and traces and get a closer read on a single run.

Exploration

The exploration views are my attempt to see how an agent moved through the codebase. Both are really trying to answer the same question: which prompts, changes, and project setup shaped how the agent explored the repo?

Project drilldown

This is the project-level view for narrowing the surface area and drilling into one slice of activity.

QMD

This is where knowledge workflows come into the picture.