Opaline

Opaline is a team-wide, message-level analytics product for coding agent sessions, built specifically for teams that work with Claude Code and Codex. Its stated purpose is to track token cost, time, and skill usage for every single message across a team's sessions, so that the full history of how people use coding agents stops being a black box. The homepage frames this simply: pull back the curtain on your coding sessions, and turn teammate struggle into learning. Opaline is aimed at engineering teams rather than individual hobbyists — its product demo is populated with a team of three named members, a set of shared repositories, and the models those sessions run on. Rather than reporting only an aggregate monthly figure, it attributes activity down to the level of individual messages, sessions, agent runs, and the people behind them. Coding agents have become both a real line item and a real part of how software gets written, yet the way teams usually measure them is coarse. A provider dashboard typically shows an aggregate spend number with little context: which teammate generated it, which repository it belongs to, which model consumed it, or what actually happened inside the session. On a shared team account, that missing attribution makes it hard to hold any grounded conversation about usage. Opaline's answer is to treat agent sessions as an analytics problem, the same way product teams treat user behaviour. Where product analytics reveals how users move through an application, Opaline reveals how colleagues move through their coding agent sessions: where the spend lands, where sessions run long, and where the language exchanged between developer and agent starts to signal friction. The stated intent is that observable teammate struggle becomes learning rather than an invisible cost. The core of the product is the analytics dashboard, and the demo shows exactly what it reports. For a selected date range — the example covers August 1 to August 31, 2026, at a Daily granularity — Opaline surfaces headline figures: API Cost, Sessions, Agent runs, and Language signals. In the demo those read $3,200.99 in API cost, 85 sessions, 1,864 agent runs, and 385 language signals. Beneath the headline numbers sits an API Cost chart plotted daily and expressed in UTC, so cost can be read day by day and compared against when work actually happened. Sessions and agent runs indicate volume — how many conversations were held and how many individual agent executions occurred — independently of what they cost. Together these counters answer the first question any team lead asks: how much are we using, how much is it costing, and when is that happening. Opaline's defining characteristic is the resolution of its data: it tracks token cost, time, and skill usage for every single message, not merely per session or per month. That per-message granularity matters because a session is rarely uniform — it may open with a cheap planning exchange and then spend most of its budget on long, iterative back-and-forth. Message-level token cost shows where inside a conversation the spend actually accumulates. Time tracking shows how long those exchanges take, which is a different measure of effort from cost. Skill usage tracking captures which capabilities the agent drew on across messages. Because every message carries these attributes, the totals on the dashboard can be decomposed downward rather than taken on faith, and any aggregate figure can be traced back to the specific exchanges that produced it. Language signals are the most distinctive metric in the product, and they are what the product's tagline hints at: the ability to catch every "You're absolutely right" from the model and every blunt, frustrated reply from a teammate. Alongside cost and time, Opaline counts these signals — 385 of them in the demo period — turning the tone of a session into something measurable. The purpose is not surveillance for its own sake but the homepage's stated goal of turning teammate struggle into learning. Repeated friction, an agent that keeps agreeing without solving the problem, or a developer who has clearly hit a wall are all patterns that show up in language before they show up in a cost report. By counting and surfacing them next to spend and activity data, Opaline lets a team treat signs of struggle as something to act on — reviewing the session, sharing what worked, or adjusting how the agent is used. Opaline breaks usage down along three axes, each shown with both an absolute value and a share of the total. The Members view lists each teammate's API cost and percentage: in the demo Rafa at $1,175.59 (37%), Evren at $1,046.61 (33%), and Marc at $978.79 (31%), across a team of three. The Repositories view attributes the same cost to codebases — evrendom/rudel at $3,104.04 (97%) and opalinehq/athena at $96.95 (3%) across two repositories — which makes the concentration of spend immediately legible. The Models view shows which model consumed the budget: GPT 5.6 Sol at $2,051.43 (64%) and Fable 5 at $1,149.56 (36%), across two models. Read together, these three breakdowns answer who, where, and on what, and they make comparisons between members, repositories, and models concrete rather than anecdotal. Opaline is distributed as an open-source command-line tool. The site labels it MIT OSS, links to its repository at github.com/opalinehq/cli, and states that it can be launched with a single command: npx opaline@latest. That command is the entry point for collecting session data from a team's Claude Code and Codex usage, which then feeds the team-wide analytics view. The demo dashboard — explicitly labelled as a product demo — supports selecting a date range and a granularity such as Daily, and presents cost over time in UTC. Publishing the source under a permissive MIT licence means teams can inspect what the tool does and how it gathers data before running it. The overall approach is deliberately reminiscent of product analytics tooling: instrument the sessions, collect message-level events, then aggregate them into team, repository, and model views on a dashboard. The benefits follow directly from that structure. Teams gain attribution: instead of a single bill, they see cost split by member, repository, and model, so it is clear where usage is concentrated. They gain resolution: token cost, time, and skill usage attached to every message make it possible to understand why a session was expensive, not just that it was. They gain an early-warning layer through language signals, which surface frustration and unproductive loops that a cost report alone would never show. And they gain a shared vocabulary for discussing agent usage, because the dashboard's figures can be referenced in a team conversation rather than debated from impressions. The homepage's framing sums up the intended outcome: turning the struggle that appears inside sessions into something the team can learn from. Concrete scenarios follow from the demo layout. A team lead reviewing an unusually expensive month can open the Members view to see whether cost is distributed or concentrated on one person, then switch to Repositories to identify which codebase is driving it. An engineering manager can compare models in the Models view to see how budget splits between them. A developer who notices a high count of language signals can go back to the sessions behind them and examine where a conversation with the agent went sideways. A team onboarding new members can use the member and repository breakdowns to understand how agent usage spreads as more people adopt it. And because the figures are daily and expressed in UTC, they can be lined up against a sprint or a release window to see how cost tracks with periods of intense work. Opaline is built for teams rather than solo users: the demo is populated with three named members, shared repositories, and multiple models, and its tagline describes it as "PostHog for team Claude Code and Codex sessions." It is a developer tool first — installed and run from the command line via npx opaline@latest — so its natural audience is engineers, engineering leads, and platform or developer-experience teams already using Claude Code and Codex at work. The site lists it as MIT OSS with source on GitHub, and the site itself is generated with Astro. No pricing tiers or plan details are presented on the website, so the commercial model is not stated there; the distribution facts that are visible are the open-source licence, the CLI install command, and the hosted analytics dashboard the demo illustrates. Opaline's value proposition is narrow and clear: it makes a team's Claude Code and Codex sessions observable at the level of the individual message. By tracking token cost, time, and skill usage for every message, and by rolling those up into team-wide views of members, repositories, and models, it replaces a single opaque spend number with an attributed, explorable picture of how agents are actually being used. Language signals add a dimension that cost and timing cannot capture on their own, exposing the friction and struggle that precede wasted budget. Distributed as MIT open source and runnable with npx opaline@latest, it is aimed at engineering teams that have already adopted coding agents and now want to understand them. The promise is the one on the page: pull back the curtain, and turn teammate struggle into learning.