De-cluttering the AI Space

Preface

Welcome to our first article from aleph0, I hope you will find it an insightful read. We’d like to start by sharing our stance on AI content, since AI is our lifeblood here at aleph0. We use AI to empower our work and help us in writing, but merely as a stylistic aid, grammar correction and to help with boilerplate. We use also use AI to implement well-described and designed components based on our architecture definition, but always with oversight.

We don’t ship “AI slop”. We hold ourselves to a high bar and deliver with care. AI should amplify creativity and productivity, not replace them. We believe that AI should be a tool that enhances human creativity and productivity, rather than replacing it.

Now, let’s dive into the first article.

The State of AI

The AI market is booming today, but it also feels over-inflated; crowded with ventures that mirror each other without building new foundations. Too many “AI products” are just slick wrappers around Anthropic, OpenAI, Cohere, or similar APIs. Better UI, a vertical niche, workflow glue, but fundamentally the same back-end.

I have respect for what OpenAI and Anthropic have built. For a reasonable monthly fee, they empower IT professionals and power users with models that would once have required massive capital to run. But even with that, most AI products don’t stray far from the same paradigm. The reason is that for most people, AI doesn’t feel like a natural extension. It feels distant, expensive, and inaccessible.

Why AI Still Feels Distant

The headlines say “ChatGPT,” but if you try to plug in your own idea, you stumble into steep costs:

• GPUs are expensive: inference, scaling, memory, model hosting - all hit you with infrastructure tax.
• Latency, orchestration, model loading, versioning - hidden complexities waiting to trip you up.
• Return-of-investment is uncertain, especially for niche use cases where usage volume can’t justify the spend.

Because of that, most promising side projects and tools never escape being an “experiment” - they die under the weight of bills, not lack of vision. Thus, you’re left with a patchwork of thin interfaces atop AI APIs, often fragile or lacking cohesive vision.

Warp: AI as Native Tooling

Let me talk about Warp - an “intelligent terminal” with AI (this is not a paid promotion - we just genuinely like it) which comes especially handy for software development and system administration tasks. It extends conventional command line with natural-language input, which allows building complex commands quickly, executing multi-step tasks to diagnose systems, explain error messages and automatically suggest code-level fixes - all without pulling you out of your shell.

Think of it as AI becoming part of your usual coding workflow, like Git.

In that shift lies a clue about what’s wrong in the wider AI product space: too many tools treat AI as an external add-on. But tools like Warp show how deeply AI can integrate into existing workflows - how it can mediate the interaction of human and machine, not just a tool that can barely summarize your emails.

But for all its UX wins, Warp still is a closed-source product that relies on centralized, third-party AI APIs, which forces user into a position of trust, while handling an extremely sensitive task. Who owns your command history, who is logging your queries - your technological strategies, proprietary code?

Privacy and Trust

Warp is a solid business built around a legitimate product that is robust and cohesive. But to truly aid the cause of AI feeling closer and being more trustworthy, we need a model built not on promises, policies, but on verifiable transparency and user control.

Companies promise robust data protection, but history provides stark reminders that policies can fail spectacularly. In October 2023, 23andMe disclosed a breach where attackers, starting from just ~14,000 accounts, leveraged linked family-tree features to access the data of approximately 6.9 million users.

The growing need for privacy, especially under regulations like GDPR, is in fundamental tension with the dominant AI paradigm - which is not just metadata-hungry; it is data-hungry. To function, public AI APIs demand the most intrusive access possible: the full, unencrypted content of your conversations, code - and to perform well, they factually need to infer thoughts and intentions of users. The irrenconcilable conflict is that the most privacy-forward products are designed to be blind to data and metadata, while the most powerful AI services demand total visibility.

Zed: A Different Path

To break that conflict, you need a product that both stands on its own and absorbs AI deeply. A product that can opportunistically monetize the hard problem of running sufficiently advanced AI models locally, but does not attempt to squeeze every last drop of data from users by vendor-locking them into public AI APIs.

That’s where examples like Zed become illuminating.

The absence of vendor-locking and aiming for longevity is a key differentiator for Zed. It allows users to bring their own models, and soon you’ll be able to bring in your own local tab completion models as well.

While it might lack in some areas, it excels via quality over quantity by building durable, high-quality infrastructure first, such as its Agent-Client Protocol (ACP) for standardizing interactions with coding agents. This signals a commitment to quality and longevity over simply chasing trends, and shows what it truly means to empower human creativity with AI.

Both Zed’s core editing functions and its AI integrations are cohesive and robust, to the point where it has all chances to overtake already established products - both conventional and AI-powered code editors. It is a phenomenal open-source code editor built in Rust, one we love to use at aleph0 - and we believe that its choice of Rust played a major role as well.

Why Rust is special

The decision to write in Rust proves to be a statement of intent. We at aleph0 believe that it perfectly balances rigor of formal systems and functional paradigm with pragmatism of imperative programming, while bringing advanced safety and native performance to the table. We celebrate Warp and Zed having chosen Rust and the success that it brought to both products.

As AI becomes a necessary tool for efficient software development, using Rust as a programming language of choice allows writing cleaner, more predictable code by acting as an expert-level safety net. It embeds contemporary understanding of programming language design acquired through decades of lessons from building software to address the challenges of modern software development, which allows building software to last.

This is why we use Rust in all of our projects, including this website. We believe there is no limit to its potential and applicability, and that it is a natural choice for building high-quality software.

The Glimmer of Hope

Emerging tools like Zed shift power back to you, the user, allowing you to use local inference and keep data under your control. Small LLMs are rapidly improving in efficiency and capability. New standards like WebNN (Web Neural Network API) are being developed so browsers can run AI inference locally, leveraging your GPU or even dedicated AI silicon, without sending data back to a server.

This shift back to the client might seem to contradict Eric Schmidt’s prescient observation made in the 1990s, that as the network becomes as fast as a computer’s backplane, the computer itself “hollows out,” with its value migrating to the network. Such an interpretation misses a crucial evolution: the endpoints themselves are becoming powerful parts of that network. Even if computation at the edge can not be as powerful as dedicated cloud infrastructure, it also scales - what was once a barebones terminal before, is now a device like a MacBook.

Dedicated AI Silicon

Modern devices increasingly include coprocessors, like Neural Processing Units (NPUs), which specialize in AI acceleration. Qualcomm’s Hexagon, AMD’s XDNA, Intel’s accelerators, and others are blurring the line: your phone, laptop or AI PC could handle serious inference locally. VeriSilicon recently announced NPUs capable of over 40 TOPS (tera-operations per second) for on-device LLM support.

Advances in Research

With the rise of coprocessing, researchers are exploring innovative ways to optimize inference performance and energy efficiency:

• llm.npu offloads parts of inference onto NPUs, cutting latency and energy use, achieving 22.4x faster prefill and 30.7x energy savings.
• PowerInfer-2 shows that even smartphones can run larger models by splitting computation intelligently across CPU, GPU, and NPU.
• HeteroLLM explores heterogeneous execution, coordinating multiple accelerators to maximize performance.

This movement matters not just for privacy or ideology - it’s about feasibility. If inference can live on your device, you eliminate a huge cost center (remote GPU hosting), reduce latency, and make AI feel native rather than forced. That’s the future we see - and it’s what we want to build toward.

aleph0

Our vision isn’t limited to private, local AI in everyone’s pocket. We also want AI to feel like part of your everyday toolset - seamless, responsive, and intuitive - like a second pair of arms and a third eye, always ready but never intrusive.

Much like Zed, we’re building tools with the polish, reliability, and performance you expect from Rust. Much like Warp, our aim is for AI to become part of your natural workflow, not an add-on you invoke.

That’s why we design every product so you remain in control of your data. We believe in private, local AI, with your data accessible only by you unless you explicitly choose to share it. We reject analytics infrastructures that harvest behavioral data - site visits, blog reading, user interactions - solely to monetize or profile. We believe passwords are obsolete constructs, overdue for expiration, and we’re building authentication paradigms that match a future of secure, local, seamless identity.

The AI industry is cluttered with noise, wrappers, and hype. We don’t need more of that. What we need are tools that integrate intelligence natively, respect the user’s privacy, and run with the same polish and rigor as the best software engineering practices allow.

That’s what we’re here to build. Not another layer of gloss over someone else’s model, but a new foundation: AI that is local, private, reliable, and truly yours.