Carbonos

AI environmental observability. Intended for marketing and green teams to understand the impact of what they are doing and tell this to the public.

Comment

Inspiration

If there's one thing enterprises need to get serious about right now... It's their AI emissions.

We're in the middle of an AI explosion, with data center power demand projected to grow 160% by 2030, driven heavily by AI. But here's the catch: while Chief Strategy Officers know AI is driving up their carbon footprints, fewer than 10% of enterprises can accurately measure their AI-related Scope 3 emissions, the largest source of indirect emissions. They know the impact is growing; they just can't see the full picture.

50,000 EU companies face Corporate Sustainability Reporting Directive (CSRD) compliance deadlines by 2028. Fines up to 10% of annual revenue if you miss them. Reputational damage if you get it wrong. And nobody has per-developer, per-use-case visibility into AI emissions.

This is why we built Carbonos, an AI sustainability observability platform that transforms raw usage logs into audit-ready CSRD compliance reports.

We wanted to build something that didn't just estimate emissions, but actually enforced accountability and made compliance effortless. We believe that making AI sustainable is everybody's responsibility, and Carbonos makes this responsibility measurable, actionable, and defensible.

What it does

Carbonos is an AI sustainability observability and governance platform built for sustainability teams, engineering leaders, compliance officers, and any enterprise racing toward CSRD deadlines.

AI workloads are consuming enormous and fast-growing amounts of energy, yet most organizations have zero visibility into which teams, developers, and use cases are actually driving their emissions, let alone a way to hold anyone accountable. Carbonos closes that gap, turning AI carbon from an invisible cost into a measured, governed, and reducible one.

Instead of relying on manual reporting, Carbonos captures AI usage automatically. It plugs directly into Claude Code's native telemetry stream, so every request, its model, token counts, and cost, flows into the platform in real time, with no code changes or manual logging. Because it's built on the open OpenTelemetry standard, the same pipeline extends to any AI tool or agent, not just Claude Code.

From that live data, Carbonos builds a fully hierarchical emissions picture, rolling up from individual requests to per-developer, per-team, per-use-case, and per-company totals. Role-based access means executives and managers see everything beneath them across the org, while individual developers see their own footprint, making sustainability personal and actionable at every level.

But Carbonos goes far beyond tracking; it helps you govern and reduce AI emissions:

  • Carbon budgets with real enforcement: set monthly CO₂e limits per team with advisory, soft, or hard modes that can flag, warn, or block usage once a budget is exceeded.
  • Green AI Score: a single, executive-friendly metric that isolates the one thing teams actually control: model choice. It cuts through raw volume to show whether teams are picking efficient models, giving leadership instant, comparable insight into sustainability health.
  • Provider transparency scorecard: ranks AI vendors by how carbon-intensive and how transparent they are, so procurement decisions factor in sustainability.
  • AI sustainability advisor: a built-in assistant that reads your live emissions data and recommends concrete reductions, turning insight into measurable action.

Whether it's surfacing wasteful use cases, enforcing budget limits, or generating compliance-grade reports, Carbonos gives enterprises a credible, defensible way to measure, govern, and shrink their AI emissions.

How we built it

We built Carbonos with a corporate-grade, enterprise-ready architecture designed for scale and compliance:

  • Frontend: Next.js 14, React, TypeScript, shadcn/ui
  • Backend: Python, FastAPI
  • Database: Supabase (PostgreSQL)
  • PDF Generation: WeasyPrint
  • Deployment: Vercel (frontend), Railway (backend)

Emissions methodology (arXiv:2606.10660): CO₂e (kg) = (tokens / 1000) × f_energy(model) × PUE × carbon_intensity

Challenges we ran into

As a team building our first enterprise-grade compliance platform, this project pushed our abilities in code, design, and domain knowledge. We had to understand how to implement peer-reviewed emissions methodology (arXiv:2606.10660) while balancing accuracy, feasibility, and auditability. Every constant we chose (energy-per-token factors, data-centre PUE, grid carbon intensity) had to be documented and defensible, because a CSRD report that an auditor can't trace back to a source is worthless.

The biggest technical challenge was the core question: how does AI usage actually get into the platform automatically? We didn't want a manual CSV uploader; we wanted real telemetry. After digging into how Claude Code works, we discovered it has native OpenTelemetry support, and built an OTLP ingestion endpoint so every request Claude Code makes streams into Carbonos in real time.

Accomplishments that we're proud of

  • Automatic, real-time AI carbon capture: Carbonos ingests live Claude Code usage over OpenTelemetry with zero code changes on the developer's side. Because it's built on an open standard, the same pipeline works for any AI tool, not just one vendor.
  • A full observability-to-governance loop in a hackathon window: we didn't just track emissions, we shipped enforcement, per-team carbon budgets with advisory/soft/hard modes that can flag, warn, or block usage.
  • A genuinely useful AI advisor: we wired in an LLM that reads a team's live emissions data and returns specific, grounded reduction recommendations, not generic advice.
  • A clean, swappable architecture: every ingestion path funnels through one normalization layer and one storage interface, so we migrated from in-memory to a real database by changing a single file. That discipline is what let us move fast without the codebase collapsing.
  • Audit-ready CSRD reports: one click produces a methodology-cited PDF with per-team and per-developer accountability trails.

What's next for Carbonos

From tracking to routing, Carbonos will evolve beyond monitoring emissions to actively reducing them through real-time nudges and intelligent model routing, automatically steering simple tasks to cheaper, lower-carbon models and only escalating to frontier models when necessary. This is where the greatest opportunities for both emissions and cost savings lie. Combined with region-aware, carbon-intelligent scheduling, Carbonos will also recommend running heavy, non-urgent AI jobs when and where the electricity grid is cleanest.

Carbonos will provide deeper visibility into enterprise AI usage through automatic use-case classification, enriching every request with its underlying workflow, such as code review, debugging, RAG, or data analysis, so organizations can identify which use cases, not just which users, are driving emissions. Building on this, a RAG-powered sustainability roadmap will generate prioritized, organization-specific recommendations and track progress toward emissions reduction over time.

On the enterprise side, Carbonos will introduce full role-based access control with Admin, Manager, and Developer hierarchies, alongside customizable dashboards that allow organizations to configure the KPIs, widgets, and budgets most relevant to them. By integrating token-level pricing with emissions data, every sustainability insight will also be tied to its financial impact, making it easier for leaders to justify sustainability initiatives and optimize both carbon and cost.

Built With

Share this project:

Updates