Apogee: A Privacy-First Browser Summarization Extension Rebuilt with Local AI After Mozilla Killed Orbit

From Orbit to Apogee: A Privacy-First Rebuild

Last year, Mozilla released an AI browser summarization extension called Orbit. It helped users quickly summarize web content and attracted considerable attention. But the honeymoon didn't last long—when community members started digging into the extension, they discovered its backend relied on servers hosted on GCP, with API endpoints like store_result. This meant that users' browsing and summarization data was being sent to remote servers for processing and storage.

GCP (Google Cloud Platform) is Google's cloud computing service, widely used for hosting backend APIs and data storage. The store_result endpoint discovered by community members through reverse engineering the Orbit extension meant that every time a user triggered the summarization feature, the webpage content was extracted and sent via HTTP requests to a processing pipeline on Google's cloud servers. This architectural pattern is extremely common in AI applications—because LLM inference typically requires high-performance GPU clusters, cloud deployment offers the best response times and model quality. However, for a browser extension, this means every browsing action and every article a user reads could potentially be logged and analyzed by a third party, creating significant privacy risks. Mozilla, an organization that has long built its brand around privacy, adopted this data-exfiltrating architecture in its own product—and this contradiction was the fundamental reason for the community backlash. Eventually, Mozilla quietly killed the project.

For privacy-conscious users, Orbit's problem wasn't just that it was abandoned—it was that data processing was designed to run in the cloud from the very beginning. This exact pain point motivated an independent developer to rebuild the tool from scratch, giving it a new name—Apogee.

The Core Difference: Fully Local Execution

According to the developer's post on Reddit, they spent about a month rewriting the entire project from scratch. The fundamental difference between Apogee and Orbit is: it runs entirely locally, neither sending nor storing any user data.

This philosophical shift strikes at the heart of today's most contentious debate around AI applications—the trade-off between convenience and privacy. As more and more AI features get crammed into browsers, users often unknowingly upload their browsing behavior, reading content, and even personal preferences to third-party servers. Apogee chose a heavier but more trustworthy path.

Technical Implementation: Multi-Engine Local Inference Architecture

Direct Connection to Local Ollama Instances

Apogee's most straightforward approach is connecting to a user's local Ollama instance for inference. Ollama is an open-source framework for managing and running large language models locally, dramatically simplifying the process of running LLMs on personal computers. Users can download and launch a complete LLM instance with a simple command like ollama run llama3. Under the hood, Ollama uses llama.cpp as its inference engine, supporting both CPU and GPU acceleration (NVIDIA CUDA, Apple Metal), and exposes a local HTTP interface compatible with the OpenAI API format (listening on localhost:11434 by default). This means any application that supports the OpenAI API—including browser extensions like Apogee—can seamlessly connect to a local Ollama instance without modifying any calling logic.

Ollama's model library currently covers dozens of mainstream open-source model families including Llama 3, Mistral, Qwen, Phi, and Gemma, allowing users to choose quantized versions of different parameter scales based on their hardware capabilities. By having Apogee call the local Ollama instance directly, all computation for summarization tasks is performed on the user's own machine, and data never needs to leave the device.

The advantages of this approach are obvious: privacy is thoroughly protected, and users have the freedom to choose which model to run. The downside is that it requires a certain level of technical expertise, and local hardware performance directly impacts inference speed and quality.

In-Browser Inference with WebGPU and Transformers.js

To lower the barrier to entry, the developer also implemented differentiated engine adaptations for different browsers:

• Chrome: Integrates WebGPU, leveraging the browser to directly call GPU-accelerated local model inference;
• Firefox: Uses Transformers.js to run lightweight models directly within the browser.

WebGPU is the next-generation browser graphics and general-purpose computing API defined by the W3C, designed to replace WebGL, which has been around for over a decade. Unlike WebGL, which primarily targets graphics rendering, WebGPU was designed from the ground up to also address general-purpose GPU computing (GPGPU) needs, providing a compute shader pipeline that makes it possible to run compute-intensive tasks like matrix operations and neural network inference within the browser sandbox. WebGPU's underlying layer maps to each platform's native graphics API—Direct3D 12 on Windows, Metal on macOS, and Vulkan on Linux—allowing it to fully leverage the hardware capabilities of modern GPUs. Chrome has enabled WebGPU support by default since version 113, while Firefox is still in the experimental support stage.

Transformers.js is a JavaScript library officially maintained by Hugging Face that ports the popular Python Transformers library to browser and Node.js environments. Its core mechanism uses ONNX Runtime Web as the inference backend, converting pretrained models to ONNX (Open Neural Network Exchange) format for execution in the browser. ONNX Runtime Web supports two execution backends: WebAssembly (WASM) and WebGPU—WASM provides broad browser compatibility, while WebGPU offers significant GPU acceleration on supported browsers. Transformers.js currently supports dozens of task types including text summarization, translation, sentiment analysis, text embeddings, and image classification, covering mainstream model architectures like BERT, T5, and Whisper. Apogee chose Transformers.js for Firefox precisely because Firefox's native WebGPU support is not yet mature, while Transformers.js can run lightweight summarization models stably in a pure CPU environment via its WASM backend.

This design means that even without Ollama installed, users can get out-of-the-box local summarization capabilities right within the browser. As WebGPU, the next-generation browser graphics and computing standard, gradually becomes key infrastructure for running AI models in browsers, Apogee's approach represents a direction worth watching.

Feature Coverage: Beyond Just Web Summarization

Apogee currently supports a rich range of summarization scenarios, including:

• Regular articles and website pages
• YouTube and Bilibili videos
• Wikipedia entries
• Hacker News discussion threads
• Reddit threads

This coverage essentially meets the daily needs of information-heavy users. The video and long discussion thread summarization features are particularly valuable, significantly reducing the time users spend digesting lengthy content. It's worth noting that video summarization typically relies on extracting subtitles or transcript text rather than directly analyzing video footage. YouTube provides API access to auto-generated captions and creator-uploaded subtitles, and Bilibili has a similar CC subtitle system. Browser extensions obtain timestamped text by parsing the page DOM or calling the platform's public subtitle APIs, then feed this text as context to a large language model for summarization. A 30-minute video typically produces a complete transcript of only a few thousand to ten thousand words—a very lightweight processing task for modern LLMs, which explains why video summarization can feasibly run on local lightweight models.

The developer also candidly admits the project is "far from complete," describing it as more of a usable early version, and is actively seeking community feedback and suggestions.

The project is fully open source, with code hosted on GitHub (github.com/darshi1337/apogee), and is available on both the Chrome Web Store and Firefox Add-ons store for easy installation by regular users.

Observations and Reflections

Community-Driven Open Source "Succession"

Apogee's creation is quite symbolic. When a large company abandons a product due to business or strategic considerations, the community is fully capable of picking it up and rebuilding it according to principles that better serve user interests. From cloud to local, from closed to open source—Apogee walks a technical philosophy that is the exact opposite of Orbit's.

A Signal of Maturing Local AI Ecosystem

This case also reflects the maturation of the local AI ecosystem. Thanks to the refinement of toolchains like Ollama, Transformers.js, and WebGPU, independent developers can now build a fully functional local AI application within a month—something nearly unimaginable two or three years ago. As open-source model quality continues to improve and consumer-grade hardware compute power grows, "local-first" AI applications are poised to become the default choice for privacy-sensitive users.

Real-World Limitations and Target Audience

Of course, idealism comes at a cost. Local inference is constrained by user hardware, and summarization quality and speed may not match cloud-based large models. For example, running a 7B parameter quantized model (such as the Q4 quantized version of Llama 3 8B) requires a model file of roughly 4-5GB and an equivalent amount of memory or VRAM for inference. On Macs equipped with Apple M-series chips, thanks to the unified memory architecture, these models can achieve generation speeds of 20-40 tokens per second, approaching a smooth experience; similar performance can be expected on NVIDIA discrete GPUs with 8GB or more VRAM (such as RTX 3060/4060). However, on a typical laptop with only integrated graphics and 8GB of RAM, the same model might slow to 3-5 tokens per second, and summarizing a long article could take tens of seconds or longer. Larger models (13B, 70B parameters) multiply the hardware requirements accordingly.

WebGPU compatibility and performance vary considerably across devices, and the Ollama-dependent approach still presents a barrier for average users. Apogee is currently best suited for tech enthusiasts and privacy-first users, and still has some distance to go before becoming a mainstream product.

Regardless, a project like this—driven by an individual developer, built around privacy, and fully open source—deserves the attention and support of the entire community. It reminds us that the convenience of AI features doesn't have to come at the cost of data sovereignty.