## On building Yggdrasil and the death of the app as we know it

We've been promised a revolution. Since GPT-3.5 exploded into the world, Large Language Models have grown faster, cheaper, and smarter. They write code better than many junior developers. They pass exams. They generate art. And yet—most people still get more practical value from a three-year-old Alexa sitting in their kitchen than from all this cutting-edge AI combined.

Something isn't clicking. The models are capable, but the interface is wrong. We're still grafting intelligence onto old paradigms instead of building from the ground up for an AI-native world.

### The Fracturing of Linear Thought

My frustration started where most technical frustrations do: staring at a linear chat interface, watching my context window fill with tangents, feeling the cognitive weight of a conversation that could only go in one direction. Human thought doesn't work this way—we explore, we branch, we chase parallel possibilities. Why should our AI conversations be any different?

This wasn't just a UI complaint. It was a fundamental architectural limitation that was only going to get worse as agents became more capable. Every tool call, every piece of context, every exploratory tangent piled into the same endless scroll. The architecture was fighting against the natural shape of problem-solving.

So I built Yggdrasil around a core directive: parallelism as a first-class citizen. Not as a feature bolted onto chat, but as the foundational architecture. The web version came together quickly—leveraging AI inference pipelines from my previous work. But I wanted more. I wanted something that ran locally, that gave users control over their data, that worked everywhere. As a solo developer, Electron was the obvious choice: one codebase, three operating systems. "Minimal extra development," I told myself. (It was not minimal at all.)

By early 2024, Yggdrasil was technically impressive—a state-of-the-art chat interface with branching threads, parallel execution, and a gorgeous native feel. I had built the ultimate chat client. The only problem? The world had already moved on.

### The Age of Agents

While I was perfecting the interface, the ground shifted beneath our feet. Chat was no longer the destination—it was the substrate. Agents were the new frontier.

What started as a weekend experiment became an obsession. I integrated the standard agentic toolkit: file operations, bash commands, glob patterns, grep searches. My custom harness wasn't just functional—it was better. The agent could improve Yggdrasil's own code, identify performance bottlenecks, suggest architectural improvements. It could search through millions of lines of logs, analyze spreadsheets, automate workflows.

But a sobering reality emerged: as a bootstrapped solo developer, I couldn't compete with Anthropic or OpenAI on token pricing. Without venture backing, I could only pass through API costs at market rates. This was a dead end. I realized that token cost optimization wasn't just a feature—it was survival.

The branching interface had already taught me something crucial: context is expensive, but rendering is cheap. While exploring ideas in parallel threads, I kept hitting the same constraint. Markdown is fine for basic formatting, but it's a straitjacket for rich interaction. The AI could generate complex analysis, but presenting it meant dumping raw data into the context window over and over.

What if I could render actual HTML directly in the chat?

### The HTML Moment

Here's where Electron's nature as a browser became a superpower. I built a simple tool that accepted HTML as input and rendered it natively in the interface. Then I asked the model to create animations. Complex charts. Interactive components. Fully functional forms with real-time data binding. It didn't break. It thrived.

This was more than a feature. It was a mental unlock. The LLM wasn't just generating text—it was generating interfaces. The separation between "what the AI understands" and "what the human sees" could be absolute. The AI could issue simple commands like "show me the data visualization" while the app handled the complexity of rendering interactive charts, processing user input, and managing state.

But the real epiphany came from failure.

### The Windows Automation Failure That Changed Everything

Emboldened, I set out to conquer desktop automation. My goal was trivial: open Notepad, write "Hello World," save it, launch a browser, search Google, then fire up Spotify. On Windows, this meant the UIA (User Interface Automation) API—Microsoft's accessibility framework.

The reality was a nightmare. Even simple applications returned dense, labyrinthine UI trees. Spotify's automation interface was a thicket of anonymous containers and dynamic controls. An LLM would drown in the verbosity. I could have built a filtering layer, but that meant constructing an entire abstraction framework—a project bigger than Yggdrasil itself.

After a day of frustration, I walked away defeated. I wasn't good enough, I thought. The problem was me.

But defeat has a funny way of breeding clarity. As I stepped back, I saw the pattern: I was trying to teach AI to navigate interfaces designed for humans. That's backwards. The insight was radical: AI will be the new interface layer between humans and computers. Not as a chatbot layered on top, but as the fundamental orchestrator.

That's when everything clicked into place. The HTML rendering. The token optimization. The branching architecture. They weren't separate features—they were components of a new paradigm. Instead of teaching the AI to navigate complex existing interfaces, what if we designed interfaces for the AI from the start?

### AI Apps: The Dual-Purpose Architecture

Today, I'm launching Yggdrasil v1.0.0—not just a version bump, but a fundamental reimagining of what software can be.

I want to introduce you to AI Apps. These aren't traditional applications with AI bolted on as a sidebar chatbot. They're dual-purpose organisms, built from the ground up for two kinds of users: humans and AI.

Every AI App runs in two modes:

- Headless Mode: A clean, documented API contract that lets the AI operate the app autonomously. The AI issues simple, semantic commands like "load today's emails" or "analyze this dataset."
- UI Mode: A rich, human-friendly interface for verification and direct interaction. All the complexity—data processing, state management, visual rendering—happens locally.

This separation is absolute. The AI never sees the raw data, only the semantic operations and results. The app never needs to understand natural language, only clear API calls.

### The Email Problem: A Case Study

Consider the simple task of checking your morning emails. Traditional agents fetch your entire inbox (say, 1,000 messages), parse them, and present a summary. You now have two copies in context—the raw data and the processed version. Your token costs scale linearly while performance degrades exponentially. Daily automation like this is simply impossible; even with hardware advances, the economics don't work.

With a Yggdrasil AI App, the model issues a simple instruction: `"Load today's emails"`. The app renders in UI mode, directly interfacing with your email server. The AI never sees the email content—only the fact that the task is complete. If you want to reply to an important message, you do it instantly in the app's native interface. No additional prompts. No tool calls. No context bloat.

This isn't just more efficient—it's architecturally correct. The AI orchestrates; the app executes. The human verifies and acts.

### The 100MB Problem

When Claude Cowork processes a 100MB dataset, it must read and transmit it to the cloud. At $100/month, an afternoon of analysis exhausts the profit margin of a seat. The pattern repeats everywhere: Cloud Cost Analysis drops from $400 per query to $0.02. Payroll Analysis happens locally, eliminating legal liability. Excel files with millions of rows process in seconds on your hardware, not hours in the cloud.

Yggdrasil builds a small local tool; the AI only sees the final answer. The efficiency gain isn't incremental—it's 10,000x.

Rather than paying for these services, you can even make operations completely free by using a local LLM via LM Studio, which Yggdrasil also supports. Your machine becomes the compute layer; the AI becomes the orchestration layer.

### Minutes, Not Months

I've been writing utilities since I was a kid, but they always lived behind complex CLI interfaces. Take FFMPEG—such a powerful tool, but a hassle to use. Building a simple video editor for my specific use case (trim video, compress for Discord's 10MB limit, format conversion) took me 10 minutes with Yggdrasil. For UI work, Gemini Flash is probably the best model, and you can completely change any custom app's UI in a single prompt.

The main secret behind Yggdrasil's rapid development is that we handle the runtime. You only need to build a simple UI and handle your app's logic via a single JavaScript file. We provide detailed instructions in the custom tools folder that give the AI model everything it needs to build the app with minimal user input.

These apps are easily shareable and installable—just copy and paste, and Yggdrasil recognizes and runs them. Build once, share with anyone. Instant adoption, zero onboarding.

### The Democratization of Automation

Computer use is an often-neglected field. We underestimate the productivity loss that comes from context switching, repetitive tasks, and the cognitive overhead of generic interfaces. With custom UI per employee—only exposing the features they use, integrated into every service and infrastructure required for their job, permissions handled and gated through the custom app itself—we can boost productivity across every sector.

I was always more focused on letting other people use the tools I built than on the scripts themselves. It's cooler if everyone can use what you build, not just yourself. Yggdrasil accomplishes this dream: even my grandma can talk to her computer for her weekend church Zoom meetup.

With our unique architecture, I believe Yggdrasil will soon automate computer use entirely. Not by replacing humans, but by empowering them—wrapping advanced AI around existing workflows without forcing disruptive change.

The future isn't chat. It's not even agents. It's AI-native software that understands both human intent and machine capability—and makes the gap between them disappear.

### A Tool for the Next Generation

When I imagine Yggdrasil's true potential, I don't just see office workers or developers. I see a twelve-year-old in Mumbai building her first automation to organize homework assignments. I see a classroom of students exploring climate data in parallel threads, each chasing their own hypotheses without breaking the group's flow. I see kids treating AI not as a homework shortcut, but as a creative collaborator—tinkering, breaking things, learning logic through immediate feedback.

The branching interface is perfect for this—it's how young minds naturally work. They ask "what if?" constantly, and Yggdrasil lets them explore every answer simultaneously without losing their place. The custom app system becomes a modern homebrew environment, promoting problem-solving and computational thinking from an early age. Build a tool to analyze your basketball stats. Create an app that generates creative writing prompts. Automate your weekend Zoom meetup for church group.

That's why I'm open to partnerships with AI providers to offer free or heavily subsidized access for students worldwide. If we can put this power in the hands of curious kids—if we can make "talking to your computer" as natural as opening a browser—we won't just be building software. We'll be building the next generation's relationship with technology itself.

The future isn't about making AI more powerful. It's about making it more accessible. Because the best interface is the one that disappears—and lets human creativity take its place.