The Bitcoin Spiral: How I Built a Live AI-Narrated Dashboard on GitHub Pages

I spent an afternoon last week building the Bitcoin Spiral , a live dashboard on GitHub Pages with no backend, no paid API key, and a frontier model writing the three-line verdict at the top of the page every six hours. The whole site costs me nothing to run. I built it to put GitHub Models through its paces, and I came away convinced that AI-narrated public content is now something a marketing team can ship without a developer in the loop.

What the dashboard does

Open the link above. The first thing on the page is a polar spiral. Bitcoin's monthly price spirals outward through fourteen years on a log scale, and the orange band running through it is the Power-Law channel (Giovanni Santostasi's 2018 model, which fits Bitcoin's long-term log-log curve with surprising stability). The spiral renders in your browser the moment the page loads.

Below the spiral sits a stack of tiles: today's price, the Power-Law fair value, the Mayer Multiple (price divided by its 200-day moving average), the Pi Cycle Top distance, MVRV, the Fear and Greed index, ETF flows, Lightning Network capacity, and the current network hashrate. Every one of those numbers comes from a free public API. CoinGecko for the price. Binance for the moving averages. Alternative.me for sentiment. mempool.space for network health. Farside Investors for the ETF flows. None of them require a registration. None of them charge me. If a feed goes down between page loads, the tile falls back to a small n/a and the dashboard keeps running.

At the top, in a tile that is hard to miss, sits a one-word verdict. ACCUMULATE today. Three or four flat sentences underneath explain the position. A frontier model wrote those sentences six hours ago. It will rewrite them in six hours. Nobody on my team will touch them.

I've been running it for three weeks. It has not broken once.

What GitHub Models is

GitHub Models is the part most readers will not have used yet. It is a hosted catalogue of frontier models from OpenAI, Meta, Mistral, DeepSeek and others, accessible from any GitHub Actions workflow via the actions/ai-inference step. The authentication is the GITHUB_TOKEN the repository already has. No separate API key. No billing account. No third-party dashboard to log into.

The free tier is rate-limited and the per-request token cap is small (mine is 280 output tokens, which is the right size for a market note and the wrong size for a long essay). Production-scale use would graduate to a paid plan or move to a different inference provider. For prototyping, for editorial dashboards, for civic projects, the rate limit is not the constraint that matters. The dashboard calls the model four times a day and the free tier handles that without coming close to the cap.

I had to triple-check the "no API key" part myself. I came in expecting at least one credential to provision. There is not one.

How I stop the model inventing numbers

The verdict word is computed in plain Python from six weighted signals: valuation (where price sits in the Power-Law channel), price-versus-fair-value, the Mayer Multiple, the Pi Cycle gap, the Fear and Greed reading, and a 7-day ETF flow score. Each signal maps to a number between -1 and +1. The weights are fixed in code. The composite is a weighted mean. The output is one of five words: ACCUMULATE, LEAN BUY, NEUTRAL, LEAN SELL, DISTRIBUTE. Run the same inputs twice, the function returns the same word twice. That is the deterministic part.

Only after the numbers exist does the model get involved. The prompt it receives says, in effect: here are four signals, here is what they currently read, write three to four calm sentences explaining the position. Do not invent or predict any number. The model never sees the spreadsheet. It sees the four sentences I want it to glue together.

The first time I ran the pipeline without that constraint, the model inserted plausible-sounding price targets it had invented from nothing. They were in the right order of magnitude. They were written confidently. They were fiction. A frontier model trained to be helpful will, asked to "summarise the position," produce a position to summarise.

The constraint is the trick. Two passes through bad output before I figured that out.

Where the architecture goes next

The pipeline runs the model inside a GitHub Action. The result gets committed back to the repository, and the static site serves a cached six-hour-old paragraph. The trade-off is the staleness: the verdict can be up to six hours old at any moment. Fine for Power-Law signals that move in weeks. Wrong for anything that moves in minutes.

That architecture is about to stop being the most interesting one available.

Chrome has been shipping a built-in AI runtime, the Prompt API , which lets a web page query a language model directly inside the browser with no network call. It is in an active origin trial through Chrome 144 and the API has stabilised around window.ai.languageModel.create(). The model itself is Gemini Nano (around 1.5 to 2 GB, downloaded once by Chrome and cached for every origin that asks). Microsoft Edge is wiring the same interface. For browsers without native support, transformers.js v4 running on WebGPU will run Gemma 4 E2B, Llama 3.2 1B, Phi-3-mini, or Qwen3-0.6B locally in 1.5 to 3 GB of VRAM. The WebLLM project exposes an OpenAI-compatible Chat Completion API, so the client code that already calls GitHub Models can call a model running in the visitor's browser tab just by swapping the base URL.

The next iteration of the dashboard regenerates the verdict in the visitor's browser in around 800 milliseconds, every time they open the tab. The GitHub Action stays in the pipeline as the fallback path for browsers that cannot host a model. The visitor never sees a stale paragraph.

For now, the GitHub Models version is what is live. I will ship the in-browser version next month and write that one up separately.

What this means for content like yours

I do consulting work, and this is the bit I want every client and marketing lead I talk to to internalise.

Most business websites have a content category called "authority content." Case studies. Industry reports. Stats pages. The one with the chart of last quarter's something-versus-something. Almost all of it is static. It was true once, it got published, and then it slid down the feed. The reason it is static is not editorial. Live data used to need a backend, a backend used to need a server, a server used to need a sysadmin and a credit card, and the AI summary at the top used to require a paid API key. That stopped being true about eighteen months ago.

A live dashboard turns one of those static stat pages into a destination. It updates itself. It earns links and embeds because it is useful rather than promotional. It proves you understand your market in a way no listicle can, because you cannot fake a working model of the thing your customers care about.

Whatever you sell, there is a live number your audience checks, argues about, or worries over. Mortgage rates. Energy prices. Race calendars. Component lead times. Hiring volumes in your sector. The S&P 500 against your client's portfolio. The right dashboard owns that number, and it becomes the page your audience opens at 8am with their coffee.

The technical floor has dropped to where a marketing team can ship one without a developer in the loop. The discipline (the model glues sentences together; the code decides what they should say) is the only hard bit, and it is hard mostly because it is unfamiliar.

The source for the Bitcoin Spiral is at github.com/richyBaxter/Mandala under MIT. Fork it. Take Bitcoin out. Point the pipeline at whatever number your audience actually argues about. If you do, send me the link.

Want one of these for your business? Get in touch .