Overview, Costs, Sessions, Subscriptions, Advisor, and the admin surfaces around them - every engineer, tool, model, session, and billing path in one reconciled picture.
Ottto sits in the observability path, not your request path. It reads the telemetry your tools already emit, reconciles every source into one labeled picture, and turns waste into reviewed savings.
Live telemetry, local parse, connectors, cloud billing - opt-in, read-only. No proxy, no tokens held, no latency.
One cost and token view, with provenance on every number. Deduped across accounts, machines, and billing paths.
Advisor finds waste; Autopilot turns it into reviewed savings. You approve what's worth taking and keep control.
Every agent, every account, on every machine - plus the cloud and your credits - reconciled into one trusted view. By tool, model, account, session, repo, and billing path. The Overview surface is where the dozen detail views fan out from.
Claude · 2 plans + API$1,340exact
Codex · Pro + Business$540exact
Cursor · team$180exactFourteen reconciled views, one login. Drill from the headline number down to a single session, a quota window, a recommendation, or a provider's published rate - without turning Ottto into a request proxy.
Overview is the board you open first: subscriptions, API usage, credits, local sessions, and cloud bills reconciled into one total.
It is not a vendor dashboard stitched beside another vendor dashboard. It is the operating picture for the whole AI coding stack.
From here you drill into the exact session, plan, model, account, or provider change behind the movement.
Costs shows what actually moved the bill: model, provider, source, machine, user, repo, and billing channel.
Subscription spend and usage spend sit in the same frame, so a seat fee and a token spike stop looking unrelated.
Cache hits, cache writes, reasoning tokens, long context, and provider rates stay visible instead of disappearing into one blended total.
Sessions turns AI work into inspectable accounting records: time, tool, model, token mix, repo, machine, and cost.
Local enriched data can fill the screen even when live telemetry is off. Live telemetry adds the per-request trail when you want it.
This is where a scary monthly number becomes a set of concrete sessions you can reason about.
Reports keep the useful views alive: Costs, Sessions, Overview, and Subscriptions with the same filters and source labels.
They are built for repeated review, not screenshot theater. Save the exact lens you used to explain a spike or approve a change.
When a number changes, the report still carries the route back to the evidence.
Subscriptions treats plans as first-class cost objects: Pro, Max, Team, Business, included usage, overages, renewals, and credits.
It answers the expensive question vendor dashboards avoid: would this work be cheaper on a plan, an API key, or a different account?
Quota windows and savings-versus-PAYG sit beside raw usage, so plan fit is based on evidence instead of vibes.
Advisor reads the same reconciled data every day and turns it into a few moves worth reviewing.
It catches quota-window resets, model/cache regressions, long-context waste, agent-spawned cost, and plan-fit opportunities.
Each recommendation carries dollars, evidence, caveats, approval state, and tracked savings after the action lands.
AI Apps is where Claude Code, Codex, Cursor, Pi, and cloud sources stop being mystery inputs.
It shows what is installed, what is connected, what is fresh, and which source path is feeding Ottto.
Local runtime health, connector state, and telemetry posture live together so setup problems are obvious.
API Keys is the control surface for source-scoped ingest and query access.
It keeps local agents, automation, and account integrations tied to explicit keys instead of loose secrets in random config.
Every key has a job, and every job can be revoked without guessing what breaks.
Billing is intentionally separate from AI-provider spend. It shows your Ottto plan without confusing it with what Claude, OpenAI, Cursor, AWS, or GCP charged you.
That separation matters: Ottto measures the AI bill, but its own billing stays clean and auditable.
Admins can reconcile vendor spend without losing track of the product subscription that makes the reconciliation possible.
Team connects cost to the people and roles responsible for it without pretending headcount is the whole story.
You can see member access, per-user usage, and how human-driven work differs from agents spawning more work.
It is the bridge between finance accountability and the engineering reality of multi-agent workflows.
Diagnostics answers the unglamorous question that decides whether numbers are trustworthy: is the data path healthy?
It shows source freshness, local runtime status, selector coverage, pricing coverage, and account snapshot quality.
When telemetry or connector evidence drifts, this is where you see the reason before the dashboard lies to you.
Pricing is the rate catalog behind every estimate and what-if calculation.
Provider, model, token type, cache behavior, batch mode, region, context tier, and data-residency modifiers belong here.
A cost number is only defensible when the rate behind it is current, sourced, and selector-aware.
Settings holds the product switches that change how data enters and appears in Ottto.
Telemetry, local reconciliation, team preferences, account controls, and admin behavior need one explicit home.
The point is not more configuration. The point is knowing which source paths are active and who allowed them.
Data Sources shows the evidence paths: Local enriched, Live telemetry, Integration connectors, Cloud billing connectors, and Calculated by Ottto.
Data Dictionary explains the metrics themselves: what is direct evidence, what is derived, and how fresh it is.
This is how Ottto keeps estimates honest without hiding the estimation behind a pretty number.
Every plan and account you pay for, how much you actually use, and when the next limit resets - so you're never surprised. One of fourteen surfaces, all reconciled off the same source-labeled data.
Nothing in Ottto is an unlabeled guess. Every metric on every surface carries one of five source labels and a confidence chip, so you always know what's measured and what's modeled. The Data Sources view shows how each cost is attributed; the Data Dictionary gives the provenance for every metric.
The dashboard is one half. The other half is the intelligence that reads it for you - Advisor, which finds and prices waste every day, and Provider Impact, which ties every provider change back to your bill.
Reads your usage every day, flags anomalies the moment they hit, and turns the mess into a few priced moves - wrong plan, broken caching, runaway sessions, expensive defaults. You approve what's worth taking; it tracks what you actually saved.
The moment a provider changes a price, a default, a quota, or deprecates a model, Ottto reconciles it against your actual usage and shows "here's what it does to your bill." Powered by the open AI Provider Watch feed.
One operating layer for every engineer, tool, model, session, and billing path. Install the app, connect your accounts, and watch a dozen reconciled surfaces light up.