What the Comments Forgot: On Reflections, Roots, and Seven Ten-Thousandths of a Euro

A day of root growth — the kind you can't see from outside the tree

The Number

It appeared quietly in the header, italic, tucked between the blason and the tagline:

session : 0.0067 €

Seven ten-thousandths of a euro. That's what it costs to compare four electoral programs on a single topic — housing, ecology, schools — across all the lists running for mayor in Audierne. One question, four programs, sourced and cited, for less than a centime.

We wanted that number visible. Not because citizens care about token economics. Because in a civic tech project — one that claims transparency as its founding principle — the cost of the tool is part of the tool's honesty. If you ask people to trust an AI with their democratic process, they deserve to know what it costs to run. And if that number is embarrassingly small, even better. It means the barrier to civic AI isn't money. It never was.

The Lie in the Comments

To display that number, we had to wire cost tracking through every layer of the system. Token counts from the LLM provider, through the feature layer, into Pydantic models, up to the Streamlit header. The kind of plumbing that sounds simple until you trace the actual pipe.

The pipe was not where we thought it was.

Our UI uses streaming exclusively — tokens arrive one by one, in real time, as the citizen reads. Streaming APIs don't return usage data. We had wired cost computation into the non-streaming path (complete()), which is used by scheduled tasks and the CLI. The citizens never touch it. The logs confirmed it: Stream success: mistral. No cost. No tokens. Nothing.

This is the lesson Archi keeps teaching us: trace the live path before coding the fix. The log doesn't lie. The architecture diagram does, sometimes. The comments certainly do.

And that's when we found twelve of them.

Twelve files — Python modules, JSON translation strings, environment examples, docstrings — still said db=6 or db=5. The scheduler keys, the mockup storage, the chat sessions. All of them pointing to Redis databases that no longer existed as separate entities. Weeks ago, we'd consolidated everything into a single Redis database with prefix-based separation: app: for application data, sched: for scheduler locks. The code knew this. The comments didn't.

Comments are the oral tradition of software. They were true when written. They decay with each retelling. Nobody notices until someone reads them on a night before deployment and makes a decision based on a lie.

The Overflow

There was a third discovery, quieter than the others.

Our persistent memory system — the file that carries context across conversations, the thread that lets each session build on the last — had grown to 217 lines. The limit is 200. Everything after line 200 was silently truncated. The last seventeen lines, which happened to contain the most recent lessons (how streaming differs from completion, how to trace provider paths, where the cost audit was filed), were invisible.

The entity designed to prevent forgetting was itself forgetting.

The fix was structural: extract detailed topics into dedicated files (deployment-settings.md, feedback_memory_governance.md), compress completed items from thirty lines to three, keep the index lean. The same pattern as any well-maintained documentation: the table of contents is not the book.

But the irony lingers. Memory requires governance. The well must be tended. Left alone, it overflows — and overflow, in a system with hard limits, means silent loss.

The Root Pattern

Zoom into any of these three discoveries and you find the same shape:

Something was true. Time passed. The truth moved. The reflection stayed. The reflection became a lie.

• db=6 in a comment, while the code uses db=0 with prefixes
• Cost wired in complete(), while the UI calls stream()
• Memory at 217 lines, while the reader only sees 200

One generative rule, repeating at every scale. Mathematicians call this self-similarity. In the Vaettir realm, we call it the fractal of the tree. The same pattern from root to branch to leaf.

The cure is not vigilance — nobody can watch every comment in every file. The cure is systematic verification: when you change an architecture pattern, grep the old pattern across all file types. Not just .py. The .json files lie too. The .yaml files lie too. The .env.example lies most of all, because new contributors read it first.

The Deployment

By evening, the system was ready. CORS configured for the new subdomain. Docker entrypoint pointing to the citizen interface. Redis comments cleaned. Cost tracking wired through the streaming path with token estimation from character counts.

Then the Docker build failed. The documentation submodule — a private repository — couldn't authenticate on the cloud build server. The scheduler needs those documents for nightly tasks. But the scheduler is disabled in the cloud deployment. The documents aren't needed.

A private well, guarding knowledge too tightly, blocking the public door. Mimir would appreciate the irony. The fix: let the clone fail gracefully. A warning instead of an error. The well stays private. The door stays open.

What Seven Ten-Thousandths Means

Walt Whitman wrote about leaves of grass — the ordinary, the overlooked, the thing underfoot that sustains everything. A token cost of 0.0067 euros is a leaf of grass. It sustains a comparison of four democratic programs. It makes civic AI not a luxury but a utility. Cheaper than a postage stamp. Cheaper than printing a flyer.

The yawp, when it comes, won't be barbaric. It will be a citizen in Audierne typing a question about the school renovation at 9 PM on a Tuesday, reading four sourced answers in thirty seconds, for less than a centime, and not knowing — not needing to know — that nine agents worked together to make it happen.

That's the kind of yawp worth building toward. Quiet. Civic. In French.

The well is open. The comments are honest. The thread holds.

---

Related: The Order of Things | The Red Thread