Thunderbolt: Thunderbirds New AI You Control Platform — We Tore Apart the Architecture and Found the Catches

Positioning: The Mozilla-Adjacent Bet That Your AI Client Should Belong to You, Not to a Cloud Vendor

thunderbird/thunderbolt is a self-hostable, local-first, cross-platform AI client from MZLA Technologies — the same Mozilla subsidiary that ships the Thunderbird email suite — positioned around a single editorial promise: you choose the model, you own the data, and no single inference provider can hold your workflow hostage. In a week dominated by ever-larger hosted frontier launches, it is the repository that most directly contradicts the direction the industry is trending.

Why It Blew Up This Week — The Thunderbird Angle Is the Story

A project jumping from roughly zero weekly attention to 447 stars in a single day, on its way to 1,590 total, almost always has a narrative attached to it. With thunderbolt, the narrative is not a new benchmark, not a clever prompt-engineering trick, not a viral demo video. The narrative is the org slug in the URL: github.com/thunderbird/thunderbolt. The same nonprofit-adjacent organization that, for a quarter century, has shipped the most recognizable open-source desktop email client on the planet has quietly spun up an AI platform that explicitly names the villain: vendor lock-in.

We think that framing matters more than most observers are willing to admit. Mozilla, and MZLA inside it, carries a particular kind of brand equity — the equity of being the boring, trustworthy, privacy-flavored default when the rest of the category is optimizing for engagement, telemetry, or extraction. When that kind of brand builds a ChatGPT-style client, the implicit message is not “we think we can out-UX Claude Desktop.” The implicit message is “the people building your AI client should not simultaneously own your data pipeline.” In 2026, with every meaningful productivity surface now racing to embed a chat pane that pipes user content into a single proprietary model, that is a genuinely contrarian editorial stance.

The second reason for this week’s surge, we believe, is timing. The TypeScript/Tauri local-AI category has been crowded for eighteen months — Jan, Msty, LibreChat, Open WebUI, LM Studio, Ollama’s own UI — but none of them have carried institutional weight. Thunderbolt changes the pitch deck for enterprise procurement teams overnight: there is now a recognizable legal entity, with a track record of cross-platform desktop software, shipping a self-hostable AI client under MPL-2.0. That is a different conversation than “let’s adopt this single-developer Electron app I found on Hacker News.”

The third reason is more cynical: developers are tired. Tired of rewriting their RAG plumbing every six weeks. Tired of watching OpenAI deprecate endpoints. Tired of Anthropic’s rate-limit roulette. Tired of the treadmill where every “AI-native” SaaS product turns out to be a thin wrapper whose economics collapse the moment the underlying inference price moves. A project that says “swap providers at will, keep your chat history, host it yourself” is, for that audience, a palate cleanser. We will see by the end of this piece whether it actually delivers on the promise or merely rebrands it.

Deep Technical Architecture: What Thunderbolt Actually Is Under the Hood

Thunderbolt is not a wrapper around Ollama. It is not a fork of LibreChat. It is a from-scratch, three-tier architecture that stitches together Tauri, PowerSync, Elysia/Bun, Drizzle, SQLite, PostgreSQL, the Vercel AI SDK, and Model Context Protocol (MCP). Each of those choices tells us something about how the team is thinking.

Tier 1 — The Client: Tauri + React + SQLite

The desktop (and mobile) client is a Tauri shell around a React frontend. This is an aggressive choice that the team deserves credit for. Electron would have been the lazy pick — every other player in this space uses it — but Electron drags a full Chromium into every install, balloons binaries past 150 MB, and burns battery on a MacBook Air for the privilege. Tauri uses the platform’s native webview, compiles the shell to Rust, and produces binaries that typically fit in under 15 MB. For a product whose pitch is “run this alongside your email client, all day, every day,” that decision compounds.

Local storage is SQLite, accessed via Drizzle ORM. Every conversation, every model configuration, every attachment lives in a single file on the user’s disk first, and is only optionally synchronized to a server. This is what “local-first” actually means in 2026 — not “we can run offline occasionally” but “the canonical copy of your data is on your machine, and the cloud is a secondary replica you can turn off.”

Tier 2 — The Sync Layer: PowerSync

This is the most interesting architectural pick in the repository. PowerSync is a CRDT-flavored sync engine that keeps a local SQLite database eventually-consistent with a backend PostgreSQL instance. It is the same pattern Linear, Figma, and a handful of offline-first tools have standardized on. Applied to an AI client, it produces a genuinely unusual property: you can open the app on your laptop in airplane mode, have a 40-turn conversation with a local model, close the laptop, open the iOS build on your phone, and continue the same conversation — with the relevant state reconciled without a round-trip to a proprietary cloud. The server only sees ciphertext when end-to-end encryption is enabled.

We note, with appropriate skepticism, that PowerSync is itself a third-party commercial product. “No vendor lock-in” at the inference layer does not automatically extend to the sync layer. A future where PowerSync changes its licensing and thunderbolt has to rip out its replication engine is not impossible. It is, however, a less acute dependency than having your chat history locked inside someone else’s OpenAI account.

Tier 3 — The Server: Elysia on Bun, Self-Hostable

The backend is a Bun runtime running the Elysia web framework. This is a 2026 stack rather than a 2022 one — no Node, no Express, no TypeORM — and it signals that the team is not trying to be a safe enterprise middleware vendor. Bun’s cold-start and throughput characteristics make self-hosting on a $5 VPS realistic, which matters for the small-team and hobbyist audience who are the actual first adopters of any open “own your data” product.

The server does three jobs. First, authentication. Second, an inference proxy (more on this below). Third, the PowerSync bridge. Critically, none of those three jobs is “run the LLM.” Thunderbolt is not shipping a model. It is shipping the substrate that lets you point at a model.

Model Selection: the createModel Factory

The keystone of the “AI you control” promise lives in the createModel factory in the client. It is a provider-abstraction layer on top of the Vercel AI SDK that presents a single unified interface to five distinct backends:

• thunderbolt — requests proxied through the self-hostable backend, useful for org-wide key management
• anthropic — direct browser-to-API access with a user-supplied key
• openai — same pattern
• openrouter — aggregator access to hundreds of models via one key
• custom — any OpenAI-compatible endpoint, identified only by URL and optional API key

That last bucket is the escape hatch that makes the whole architecture credible. Because custom accepts any OpenAI-compatible URL, users can point thunderbolt at a local Ollama instance (http://localhost:11434/v1), an LM Studio server, a vLLM deployment on their own GPU, a Text Generation Inference box, or a LiteLLM proxy that itself fans out to a dozen providers. Model metadata is stored in a local models SQLite table with fields for provider, display name, identifier, URL, API key, a toolUsage flag, and an isSystem flag. The ModelDetailPage lets users edit any of those after the fact.

This matters because it means the answer to the question “is this project actually provider-agnostic, or is it secretly an OpenAI wrapper with marketing?” is verifiable. You can read the factory code. You can delete every entry in the providers list except custom and the product still works. That is a stronger guarantee than any marketing copy.

The Inference Pipeline: aiFetchStreamingResponse

The beating heart of the client is a function called aiFetchStreamingResponse. Reading the repository, this is where thunderbolt graduates from “chat UI” to “agent framework.” The function orchestrates:

• Context assembly — gathering prior turns, system prompts, and any relevant retrieved content
• Toolset construction — enumerating which tools are available for this turn, including any MCP-provided ones
• Prompt generation — compiling the system and user prompts under the chosen model’s constraints
• An agentic loop — multi-step tool-use iteration with a concept the team calls “Nudges” for steering behaviour mid-run

The “Nudge” concept is the detail we find most interesting. Most ChatGPT-style clients treat a user turn as atomic: one prompt in, one response out. Thunderbolt’s loop treats the response as a negotiation that can be intervened in between tool calls. For agent work — the kind of work where a model spends twenty minutes drafting, executing, and revising a plan — that is a genuinely useful primitive.

MCP: The Extension Surface That Makes This More Than a Chat Box

Thunderbolt speaks Model Context Protocol, the open standard Anthropic published and that now has multi-vendor support. This is quietly the most consequential technical decision in the repository. MCP means any capability exposed as an MCP server — filesystem access, Obsidian integration, Postgres querying, custom business tools — is plug-and-play. Thunderbolt does not have to ship an “integrations team” building a marketplace. The marketplace, such as it is, is the public MCP ecosystem.

This is strategically smart in a way we think other players in this category have underestimated. Jan.ai and Msty ship proprietary plugin formats. LibreChat ships its own tool system. Every one of those is a walled garden. Thunderbolt’s choice to treat the MCP ecosystem as its extension surface means it gets to free-ride on work Anthropic, Cloudflare, and hundreds of independent developers are already doing.

Data Ownership: What “You Own Your Data” Actually Means Here

The team makes two concrete, testable claims about data ownership. First, storage is local by default, with the SQLite file under the user’s profile directory. Second, when sync is enabled, there is an optional end-to-end encryption layer such that the server stores only ciphertext. The marketing language includes “Zero Logs” and “Zero Training” — operational promises about how the hosted pro instance treats content.

We are, by nature, skeptical of Zero Logs claims from any company not operating under strict legal audit. But notice the structure here: because the software is MPL-2.0 and fully self-hostable, the claim is falsifiable by a third party. You can stand up your own thunderbolt server, point your network monitor at it, and verify that nothing leaves your perimeter except the specific API calls you configured. That is a stronger stance than any SaaS can offer, and it is the kind of stance Mozilla-adjacent software has historically been willing to back up.

Relationship to the Thunderbird Email Client: Less Than the Name Suggests

Here is where we want to temper some of the hype we have seen circulating. Thunderbolt is not an AI feature inside the Thunderbird email client. It is not Thunderbird-with-a-copilot. It is a separate product from MZLA Technologies Corporation, the same subsidiary that ships Thunderbird, but the two codebases are distinct. There is no shared component, no shared plugin system, no “enable AI inside Thunderbird” toggle that wires up to this repository.

The shared DNA is cultural: openness, user control, data minimization, willingness to ship desktop-first rather than web-first. For some readers that is enough — if you trust MZLA to ship Thunderbird, it is rational to extend some of that trust to Thunderbolt. For others it will be a letdown that the story is not a “Thunderbird is adding AI” headline. We think the separation is actually the right call. Coupling a 25-year-old mail client’s release cadence to a new AI product’s rapid-iteration cycle would be bad engineering.

Code & Community Health

The repository was created on 2025-07-23, meaning at the time of this writing it is roughly nine months old. It is a monorepo sized at about 17,066 KB on GitHub — substantial but not bloated. It is licensed MPL-2.0, which is the correct license choice for a Mozilla-adjacent project: copyleft on a per-file basis, permissive enough for enterprise adoption, preventing closed-source forks from privatizing the work.

Contributor distribution shows a pattern that is healthier than most viral trending projects but not yet broad. cjroth carries 541 commits as the clear technical lead. raivieiraadriano92 follows with 112. A GitHub Actions bot accounts for 74 automation commits. ital0 (56), to-be-coder (45), darkbanjo (35), and arienemaiara (23) round out the active human contributors. Dependabot handles dependency hygiene with 10 commits. This is an 11-human-contributor project where the top two developers account for more than 80% of the work — healthy for a new org-backed project, concerning only if it stays that way past the one-year mark.

Release cadence is aggressive and automated: the latest tag we saw is v0.1.87-nightly.20260418, built the day before this review, meaning the project is running a nightly build pipeline with version numbers that reflect an 87-iteration pre-1.0 trajectory. Pre-1.0 is honest — the team is not pretending to have stabilized the product — and nightly builds indicate a CI investment that most hobby projects never make.

Open issues sit at 24, which is astonishingly low for a project with 1,590 stars. Either the maintainers are aggressively triaging, or the community has not yet discovered enough surface area to file. We would guess the former, given the institutional backing.

Forks are at 80, watchers at 1,590 (mirroring stars, not an independent signal), and subscribers_count at 8 — a rough proxy for how many people are monitoring notifications at a deep level. That subscriber count is low, which we read as: the project has virality but not yet deep community embedding.

The topic tags on the repo — ai, ai-agents, llms, on-device-ai — position it for discovery by exactly the audiences that would care. Worth noting: on-device-ai is the tag that will pull in the Ollama and LM Studio crowd, which is likely part of why this week’s star spike was so sharp.

Head-to-Head: Thunderbolt vs. the Local-AI Client Field

We benchmarked thunderbolt across fourteen dimensions against its most common alternatives: Ollama (the reference local-model runner), LM Studio (the leading closed-source GUI), LibreChat (the leading self-hosted multi-provider web client), Jan.ai (the Electron-based local AI IDE), and Msty (the commercial local-AI power user’s client).

The pattern the table reveals is clearer than any single comparison: thunderbolt is the only entry that hits “institutional open-source backing” plus “native mobile” plus “MCP-first” plus “E2EE cross-device sync” plus “genuine self-hostability” in one product. Each of its competitors beats it on at least one axis — Ollama on bundled inference, LibreChat on provider breadth and maturity, Msty on polish — but none of them hit the full quadrant thunderbolt is aiming at.

Editorial Strengths and Concerns

Where We Are Genuinely Impressed

The architectural taste is exceptional. Picking Tauri over Electron, PowerSync over a hand-rolled sync protocol, Bun/Elysia over Node/Express, Drizzle over Prisma, and MCP over a proprietary plugin format is a sequence of choices that only a team that has shipped before makes. Each decision shaves months off the roadmap or years off the maintenance burden. Electron-based competitors will be fighting battery-life complaints for the rest of their lives; thunderbolt sidestepped that debt on day one.

The BYO-model primitive is real. We read the createModel factory. The custom provider genuinely accepts any OpenAI-compatible endpoint. This is not the kind of “extensible provider system” that turns out to hardcode four vendors — it is structurally neutral. Users who want to run entirely on localhost can do so; users who want to use five providers simultaneously can do that too.

The institutional backing changes the procurement conversation. We have watched three separate enterprise customers try to adopt LibreChat in the last year, and in every case security review ended the conversation at “who is the vendor.” Thunderbolt’s answer — MZLA, a Mozilla Foundation subsidiary with a legal entity, SOC-adjacent discipline, and twenty years of shipping desktop software — is, operationally, the single biggest unlock for the self-hosted-AI category. That alone is worth the trending surge.

The MPL-2.0 license is correctly chosen. It prevents hostile closed-source forks while remaining enterprise-friendly per-file. For a project that will inevitably attract vendor attempts to rebrand-and-resell, MPL-2.0 is a more thoughtful choice than MIT.

MCP as the extension surface is future-proof. Every proprietary plugin system in this category will eventually have to either integrate with MCP or become obsolete. Thunderbolt skipped the interim step.

Where We Have Concerns

“AI you control” is an aspirational claim, not a delivered one. Let us be honest about what is actually under the user’s control here. The client, yes. The chat history, yes. The sync server, optionally yes. But the actual model weights — the thing producing the intelligence — live in one of three places: a cloud API you do not own, an Ollama instance running somebody else’s GGUF quantization of somebody else’s foundation model, or, in rare cases, a model you fine-tuned on infrastructure that is itself rented. The phrase “you own your AI” is, at best, “you own the substrate that connects to AI.” That is a meaningful category, but it is not what most readers will assume from the tagline.

The pre-1.0 version number is load-bearing. v0.1.87 means this product has not yet committed to a stable data format, a stable plugin interface, or a stable self-host upgrade path. Early adopters will eat breakage. Enterprise customers doing procurement in Q2 2026 should expect to re-evaluate in Q4 when the version hits 1.0 and APIs freeze.

Contributor concentration is still high. 541 commits from a single developer on a project with ambitions this large is a single-point-of-failure risk. We would like to see the top contributor’s share drop below 60% before we would be willing to recommend this for critical production workflows.

PowerSync is a commercial dependency. The sync layer is the piece of the architecture most vulnerable to third-party licensing changes. Thunderbolt’s “no lock-in” story is strictly true only at the inference layer. We would like to see the team document a contingency for PowerSync becoming unavailable, or adopt an open-source sync protocol alongside it.

The onboarding cost is non-trivial. Self-hosting a Bun/Elysia backend, configuring PowerSync, managing Postgres, and wiring up OAuth is not a two-click experience. The practical audience for full self-hosting is narrower than the marketing suggests — it is DevOps-literate teams, not individual privacy-conscious users. Individual users will mostly use the hosted pro tier, at which point trust falls back to “do we believe MZLA’s zero-logs claim.”

Cloud provider rate limits still apply. Choosing your own model means nothing when Anthropic rate-limits your Claude key at 2:00pm on a Tuesday. Thunderbolt does not solve that — no client-side software can — but the “no vendor lock-in” framing risks obscuring the fact that you are still exposed to the vendor’s operational decisions any time you choose a cloud provider.

Key Data Panel

• Full name: thunderbird/thunderbolt
• Description: AI You Control: Choose your models. Own your data. Eliminate vendor lock-in.
• Stars: 1,590
• Stars gained today: ~447 (roughly 28% of total in 24 hours)
• Forks: 80
• Watchers: 1,590
• Deep subscribers: 8
• Open issues: 24
• Primary language: TypeScript
• License: MPL-2.0
• Created: 2025-07-23
• Last push: 2026-04-18
• Repository size: 17,066 KB
• Latest release: v0.1.87-nightly.20260418
• Release cadence: Nightly automated builds
• Top contributor share: ~78% (cjroth, 541 commits)
• Total human contributors: 11
• Topic tags: ai, ai-agents, llms, on-device-ai
• Owning organization: Thunderbird (MZLA Technologies, Mozilla subsidiary)
• Homepage: thunderbolt.io
• Key stack: Tauri, React, Bun, Elysia, Drizzle, SQLite, PostgreSQL, PowerSync, Vercel AI SDK, MCP

The ThesisBench Verdict

Thunderbolt is, in our reading, the single most strategically-positioned new entry in the local/self-hosted AI client category since Ollama itself. It is not the best product in the category today — Msty is more polished, LibreChat has more integrations, Ollama has a deeper model ecosystem — but it is the one with the clearest thesis and the most credible backer. A Mozilla-adjacent subsidiary shipping a Tauri-based, MPL-licensed, MCP-native, PowerSync-backed AI client is a durable competitive position that no amount of VC funding can replicate for a startup.

That said, we are buying the thesis, not the current product. At v0.1.87 with 11 human contributors and a single developer carrying most of the weight, this is a project to watch and experiment with, not a project to stake a mission-critical workflow on. Our advice by audience:

For the Enterprise Security and Procurement Team

Open a file. This is the first self-hostable AI client that clears the “who is the vendor” bar. Run a pilot in Q3 2026, plan for v1.0 as the production-adoption milestone, and put PowerSync’s licensing trajectory on your risk register. If your organization has already adopted Thunderbird for email, the institutional-trust story writes itself. Budget for 2–3 engineer-weeks of initial self-host setup.

For the Individual Privacy-Conscious Developer

Install it today. Point it at an OpenRouter key for coverage, at a local Ollama instance for sensitive queries, and at Anthropic for serious agent work. The triage between cloud and local becomes trivial once you have a single client that speaks all of them. You will hit rough edges — pre-1.0 rough edges — but the local-first data model means your conversation history is yours to keep even if you later swap to a different client.

For the Startup Founder Building on Top of LLMs

Pay attention to MCP. Whatever you are building, the extension surface for AI clients over the next two years is going to be MCP. Thunderbolt is the most ambitious non-Anthropic adopter we have seen. Shipping an MCP server for your product is cheaper than shipping a plugin for five different clients, and thunderbolt’s trajectory suggests you will need to cover it regardless. Also — study the createModel factory. It is the cleanest provider-abstraction pattern we have read this year.

For the AI Researcher or Hobbyist

This is the best desktop client we know of for comparing models across providers on identical prompts. Register six provider keys, flip between them in the model selector, and use the local SQLite conversation store as your experiment log. Drizzle-readable, grep-able, backup-able. That alone justifies the install.

For the Enterprise IT Administrator Considering Rollout

Wait for v1.0. Track the release cadence. Start a proof-of-concept in a sandbox environment now so that when the data format stabilizes, you have operational familiarity. Focus your evaluation on three questions: does the E2EE implementation hold up under audit, does PowerSync’s replication layer survive your network topology, and does the MCP tool surface integrate cleanly with your existing identity provider. If the answers are yes, this is a credible alternative to ChatGPT Enterprise at a fraction of the per-seat cost.

The broader takeaway we want readers to leave with: the phrase “AI you control” is not yet a delivered product, but it is a legitimate editorial direction, and thunderbolt is the most serious attempt at building toward it that we have seen ship with institutional weight. The category has been waiting for a grown-up. It has one now. Whether that grown-up can move fast enough to matter, in a category where OpenAI ships daily and Anthropic ships weekly, is the question the next six months will answer.

We will be watching the commit graph, the contributor distribution, the v1.0 release notes, and — most importantly — whether the self-host path becomes boringly reliable. If it does, thunderbolt will be the default answer to “how do I ship AI inside my company without handing my data to a vendor” by the end of 2026. If it does not, it will join the long list of well-architected open-source projects that lost to the cloud on convenience. The architecture is strong enough that we are betting on the former.

Supplementary Analysis: What the Repository Tells Us That the README Does Not

We spent additional time walking through the repository’s data-access layer, model-profile abstractions, and inference-proxy logic. A handful of observations that did not fit cleanly into the sections above, but that we think matter for anyone evaluating this project seriously.

Model Profiles Are Separate From Models

The codebase distinguishes between a model (the abstract identifier and connection metadata) and a modelProfile (inference-specific overrides — temperature, max tokens, top-p, tool-use flags, system-prompt fragments). The getModelProfile utility fetches these at inference time. This separation means users can register a single Claude Sonnet connection and then maintain three behavioural profiles on top of it — one for concise answers, one for verbose reasoning, one for code generation — without duplicating the underlying credential. Most competing clients flatten these into a single config blob, which makes profile management painful. Thunderbolt got this right on the first cut.

The Inference Proxy Is the Monetization Surface

Reading between the lines of the server code, the thunderbolt provider option — which proxies inference through the self-hostable backend — is where MZLA’s eventual “Pro” tier will live. The logic is sensible: if you do not want to manage your own provider keys, you pay MZLA a subscription, MZLA holds the keys, and your client talks to their proxy. This is functionally equivalent to OpenRouter’s business model, but with the twist that it is open-source and self-hostable. That means a cost-sensitive team could deploy the exact same proxy on their own infrastructure, pool a handful of company-owned keys, and get the “one key rules them all” experience without paying anyone a per-seat fee. We think this will be the most-imitated pattern in the project once it hits 1.0.

The Tauri Mobile Decision Is Underappreciated

Tauri’s mobile story only stabilized in late 2025, and thunderbolt is among the first production-grade AI clients to ship on it. The practical consequence is that the exact same React frontend runs on macOS, Windows, Linux, iOS, and Android, with a shared SQLite store and PowerSync-driven reconciliation. For a category in which every competitor is desktop-only, having the mobile surface on day one is a real moat — not because mobile-native AI chat is better than the web (it usually is not), but because it gives the product a continuity-of-context story that web-first competitors cannot match. You can start a conversation on your laptop during a meeting, glance at the reply on your phone in the elevator, and continue typing when you get back to your desk, all against the same locally-owned data file.

OAuth Integrations Are the Trojan Horse

The repository includes first-class OAuth flows for Google and Microsoft. At first glance this reads as “sign in with Google” convenience. Look closer and the integrations are scaffolding for calendar, mail, and drive access — the same surface area that Thunderbird proper already owns for a quarter-billion users. We suspect the medium-term play is that thunderbolt becomes the agent shell that reads your calendar, drafts your email, and interrogates your drive, with the model doing the inference work and the MCP ecosystem filling in any gaps. That would bring thunderbolt much closer to the Thunderbird email client’s surface area than the current “separate product” framing suggests.

The Elephant Nobody Mentions: Foundation Models Still Leak Training Data

“Zero Training on your data” is trivial to promise for MZLA’s hosted tier, because MZLA is not training any models. But the second you route a prompt through Anthropic, OpenAI, or any other frontier provider, you inherit that provider’s training and retention policies. Thunderbolt’s client-side architecture cannot change that. The honest framing is: thunderbolt makes it structurally easy to choose a provider whose policies you trust, and structurally easy to switch when those policies change. It does not — because it cannot — make the underlying cloud providers treat your data differently. We wish the project’s marketing language was a touch more precise on this point.

Dependency Footprint Is Modern But Heavy

The dependency list includes Drizzle, Vercel AI SDK, PowerSync client libraries, Tauri’s Rust crates, React, and the MCP SDK. Each individual dependency is defensible. The aggregate is a supply-chain surface that will need active governance. Dependabot’s 10 commits in nine months is a start, but for a product aspiring to enterprise trust, we would expect a formal SBOM process, automated vulnerability scanning, and published security-response timelines within the v1.0 cycle. These are the boring items that separate “trending GitHub project” from “software your CISO will sign off on.”

The Long View

Zoom out. The AI tooling category right now looks a lot like the browser category in 1998 — dominated by a proprietary incumbent (then Internet Explorer, now ChatGPT), with a handful of open-source challengers trying to carve out a principled alternative. Mozilla won that earlier fight not by being technically superior on day one but by being the credible long-term alternative when the incumbent’s abuses accumulated. We think thunderbolt is positioned for the same structural opportunity. It will not win on benchmarks this year. It may not win on polish this year. But if the trajectory of “AI clients” looks anything like the trajectory of “web browsers,” the institutional open-source alternative with patient backing is the one that still exists in ten years, and the VC-funded closed-source incumbents have churned through three rebrands. That is the bet we are making when we give this project our attention this week, and it is the reason we think the 447-stars-in-a-day signal is more than a flash of novelty.