What We Are Building at aleph0

Evolving Search

Search is outdated. A user’s browser overflows with tabs and bookmarks, but when it’s time to act, they’re lost in a maze of manual searching and guesswork. Searching is a skill humans are not very good at. The result of all this is drift: attention gets fragmented, and the supposed productivity stack becomes a stack of friction.

We respect the craft behind the default search experience: giants have poured billions into ranking relevance. Still, those experiences remain built for an average user and an ad economy, not for quick routing to the correct destination. The labor of clarifying intent, choosing the right corpus, and correctly writing the search query sits on the human. route0 exists to shift that labor back to the machine without forcing anyone to surrender their data to anyone.

route0 Domain – “I’m Feeling Lucky”

route0 “Domain” is a browser extension that lives in your address bar. It is not a novelty UI for hosted LLMs. It is a small, private copilot that does three things, locally:

• Understand the intent: observe the query on device and keep the work local.
• Choose the route: predict the best destination and route the query with deterministic DuckDuckGo bang targets, so a literature query can jump to !scholar instantly.
• Present options: let the user pick, while making a safe best-effort choice when the user does nothing.

A simple example. You type how to cook pasta. Once you hit return, route0 Domain rewrites the query to !youtube how to cook pasta. The extension then sends you directly to the relevant search results on the target website. No history spills, no remote inference. That kind of routing; fast, private, and practical, is what route0 does from day one. It is the original experience of “I’m feeling lucky”, but better.

route0 Codomain – The Business Offering

route0 “Domain” is a consumer-facing expression of a larger system, route0 “Codomain”. It is designed around four principles:

• Manifest-driven configuration: models and logic are declared with a manifest that specifies how to load models, what inputs and outputs look like, and when to activate them.
• Schema and pipelining: validate inputs, outputs and chain models together, enabling end-to-end inference flows.
• Resource awareness: models load and unload based on triggers and policies.
• SDK and integration: a lightweight SDK for web apps and enterprise portals to advertise their capabilities and accept local inference from route0 Codomain.

The same core can solve far more than address-bar routing. route0 Codomain enables site-driven model hot-swapping, deterministic integration with internal portals, and predictable resource management on constrained devices. route0 Domain reuses the core of route0 Codomain for local inference; the platform underneath is what makes everything composable and allows organizations to build their own interfaces for arbitrary AI models, and deploy those models directly to the desired devices through existing enterprise browser account management tools.

The 0rthos Engine

At the core of route0 Codomain is 0rthos (read “Orthos”). It is a runtime for low-latency, on-device inference and the subsystem that turns model artifacts into predictable behavior on real hardware.

The execution environment of 0rthos is a WebAssembly core augmented by the WebGPU acceleration and the forthcoming Web Neural Network API so we can tap GPUs and NPUs directly from the extension. This combo is what allows the model to remain lightweight yet responsive – request latency will be measured in milliseconds, not seconds. As WebNN vendors roll out hardware acceleration, the same model scales down to mobile devices and scales up to x86 workstations without code forks. The browser stops being a thin client and becomes a sovereign compute surface, precisely the inversion of the 1990s prediction we cited in “De-cluttering the AI Space.”. We are betting on that inversion.

We designed route0 so engineers can treat local inference like any other client-side capability. 0rthos runs the model with deterministic operator semantics, and the SDK transparently handles tokenization, detokenization, and formatting inputs suitable for route0 which returns typed outputs that the site or extension can consume. The goal is to remove glue code, not to invent a new stack; teams ship ONNX-compatible models, 0rthos takes care of efficient execution, and the SDK ties the runtime to real web pages and workflows.

The Tech Behind 0rthos engine

0rthos implements a SIMD-accelerated WebAssembly core that uses either WebGPU or the upcoming WebNN so the same binary uses the best hardware acceleration API available on the device, while still allowing graceful fallback to CPU. The runtime supports a wide range of quantized kernels commonly involved in model graphs, and features a scheduler that enforces unload windows, batching policies, and memory accounting, all to stay slim for execution at the edge, without surprising the user or the system administrator with uncontrolled resource usage.

We think deployment should feel familiar to ops teams. The control plane supports staged rollouts, rollback, and per-namespace feature flags so administrators can push a model to 10 devices for validation, then expand to thousands. Progress is visible in an operational console that shows model activation counts, distribution health, and resource pressure trends. When a device signals low memory, 0rthos prefers eviction, keeping user experience consistent while protecting system integrity.

Because 0rthos focuses on low-latency and local reliable execution, it becomes the substrate for products that require stateful, on-device intelligence. axiom0 will layer on top of 0rthos which will allow us to do intelligent knowledge management without the user’s data ever leaving their device. In short, 0rthos makes low-level work trivial so higher-level products can focus on user value rather than runtime edge cases.

Roadmap

The immediate focus is the route0 Domain alpha for individual users followed by a developer track for SDKs and a limited route0 Codomain pilot with enterprise partners. Our priorities are robustness, predictable performance across device classes, and enterprise-grade governance. If you are building systems where data residency, latency, or auditability matter, route0 Codomain will be the tool you use to deliver AI without rewriting your security policies.

Much like Warp showed how AI can live inside the terminal, route0 shows how it can live inside the browser. Much like Zed championed Rust for cohesive tooling, route0 demonstrates that the web can host trustworthy computation when we treat WebAssembly and WebNN as first-class citizens. We believe in private, local AI, in extensions that feel like instinct rather than intrusion, and in a future where intelligence is ambient yet respectful. route0 is the first mile of that journey, and we cannot wait to hand it to you.