Carbo

Save 5% of your enterprise Purchasing expenditure and decrease your carbon footprint by intelligently finding alternatives to current expenses.

Comment 5

Inspiration

Starting in 2026, a huge number of small and mid-size European businesses will be required to report their carbon footprint under new EU rules (CSRD and VSME).

On paper, that sounds reasonable. In reality, it’s a mess.

Roughly 800,000 SMBs are affected. A carbon accountant costs around €30,000 per year. Existing tools take weeks to onboard and depend on invoice data most businesses don’t have cleanly structured.

So what actually happens?

Most companies will ignore it, guess, or buy offsets that don’t really solve anything.

We spent the first hour of the hackathon looking at bunq transaction data and realised something obvious:

The bank already has everything.

What you bought. From who. For how much.

That is exactly the data a carbon accountant works from, except here it’s already structured and streaming in real time.

So we built Carbo.

Instead of forcing businesses to manually reconstruct their footprint, we turn that existing data stream into something usable.

You open the dashboard, answer two or three questions, click Approve, and you’re done.

What it does

The moment a payment lands in your bunq Business account, Carbo estimates the carbon footprint of that purchase.

Not just a number, a number with context. Each estimate comes with a confidence range, so you can immediately see what’s solid and what’s a guess.

Once a month, everything runs through a pipeline of agents working together:

  • A baseline step calculates everything deterministically (no AI involved)
  • A research step looks for greener and cheaper alternatives
  • Two agents propose improvements: one focused on carbon, one on cost
  • Two “judge” agents check whether those proposals actually hold up
  • A strategy step decides how much to allocate to EU-certified carbon credits
  • A final step turns everything into a clear, human-readable report

After that, you’re not flooded with questions.

You get two or three, only for the biggest and most uncertain items. No one cares about a €12 SaaS subscription, so we don’t ask about it.

Then you approve it.

Money moves into a Carbon Reserve sub-account through a real, signed bank transfer. A full report is generated. Every step is logged.

Done.

In our demo: 61 transactions, €39,000 in spend, 4.8 tonnes of CO₂ allocated to EU credits, full audit chain, full report.

How we built it

The stack

Next.js 16 and TypeScript on the frontend. SQLite as the database, just a single file, no setup.

For AI, we used Anthropic’s Claude models:

  • Haiku 4.5 for fast merchant classification
  • Sonnet 4.6 for refinement and writing

We also built our own bunq client from scratch, including the cryptographic signing required to interact with their API.

The 8-agent pipeline

The pipeline lives in lib/agents/dag/.

Each agent does one thing, hands off to the next, and stays tightly scoped.

The key design decision was simple:

AI suggests. Code decides.

Agents can propose ideas, but they cannot invent numbers or move money.

Every claim gets checked by deterministic code:

  • Do the sources exist?
  • Does the math add up?

If not, it gets rejected.

A workflow that survives a crash

The monthly process has about twelve steps:

  • ingest transactions
  • classify merchants
  • estimate emissions
  • ask refinement questions
  • apply answers
  • propose actions
  • execute transfers

Each step is just a database update:

“If state = X → move to Y”

If the system crashes halfway through, you restart it and it continues exactly where it left off.

A tamper-proof audit log

Every action is written to a log where each entry is cryptographically linked to the previous one.

  • Append-only
  • No edits
  • No deletes

If anything is changed, the chain breaks and the UI immediately flags it.

Confidence math that actually means something

Each transaction carries uncertainty:

  • how sure we are about the category
  • the emission factor
  • the pricing

When we aggregate, we use proper statistical methods, not rough averages.

Then we rank transactions by:

spend × uncertainty

So the system only asks about things where being wrong actually matters.

The bunq side

This is not mocked.

  • Real signed API client
  • Real authentication flow (install, device, session)
  • Real sub-account creation
  • Real transfers
  • Real webhook verification

Everything runs in mock mode by default, but one environment variable switches it to the live bunq sandbox.

The pitch deck

We built the entire pitch deck as a 13-stage scrolling canvas at /demo-deck.

It is one React tree.

Nothing disappears or reloads, every transaction, agent, and recommendation is a persistent object that moves between stages.

It feels like one continuous shot instead of a slideshow.

Challenges we ran into

Stopping the AI from making up money

Our first version let AI propose and judge its own outputs.

It looked clean, but it was risky confident hallucination could pass through.

We fixed it by splitting responsibilities:

  • AI proposes
  • Code verifies

Financial logic is now entirely deterministic.

Asking the right questions

Initially, we asked about the lowest-confidence transactions.

That led to useless questions (like a €4 coffee).

We switched to ranking by:

spend × uncertainty

Now you get two meaningful questions instead of twenty irrelevant ones.

Talking to bunq

Every request needs to be cryptographically signed. Every webhook needs to be verified.

We built a full signing layer and automated the entire setup:

  • key generation
  • installation
  • authentication
  • sub-account creation
  • webhook registration

Now the demo runs in one command.

A laptop almost died

Our database driver compiles native code.

On the wrong Node version, it used 18GB of RAM and froze a machine. Twice.

We fixed it by pinning Node and documenting it clearly.

Making the demo feel cinematic

We didn’t want slides. We wanted flow.

Everything is one moving system.

The hardest scene is where:

  • a transaction lifts out of a list
  • expands into a focus card
  • a receipt animates in beside it

All as one coordinated motion.

Accomplishments that we're proud of

  • A real bunq client that moves money in a sandbox (one flag away from live)
  • An 8-agent pipeline where AI proposes and code enforces correctness
  • Automatic CSRD-compliant PDF reports with full audit trails
  • A crash-safe workflow built on simple database state transitions
  • A 13-stage interactive pitch deck built inside the product itself
  • A full end-to-end demo built in 12 hours by a team of four

What we learned

Take the math away from the AI

The AI never touches numbers.

It only explains them.

Code checks beat AI checks

Adding more AI layers does not fix hallucinations.

Simple rules do:

Reject outputs without sources Reject outputs with incorrect math

Database state machines are underrated

We did not use a workflow framework.

We used database state transitions.

It is simple, reliable, and automatically restart-safe.

Built With

  • anthropic-claude-api
  • better-sqlite3
  • bunq-api
  • bunq-webhooks
  • drizzle-orm
  • google-apis-/-gmail
  • lucide-react
  • motion
  • next.js-16
  • node.js-22
  • react-19
  • react-pdf
  • recharts
  • sqlite
  • tailwind-css-4
  • typescript
  • zod
+ 25 more
Share this project:

Updates