Why We Built an OS for AI — and What Taku 1.0 Taught Us

Nobody knows what to do with AI right now.

You've felt it. You ask a chatbot to fix your calendar chaos, and it hands you a bulleted list of instructions for you to follow. You ask an AI app builder for a tool, and it generates something beautiful that dies somewhere between "here's your code" and "it actually runs." You open an AI code editor because someone on Twitter said it changed their life, and you close it four minutes later because you are not, in fact, an engineer.

The models are brilliant. Your life is not noticeably easier.

Why?

Because intelligence was never the bottleneck.

Execution was.

That one observation is why Taku exists. This post goes back to where it started, Taku 1.0 in November 2025, because the question we asked then is the one the entire industry has spent the last nine months answering.

The question underneath everything

Taku 1.0 was our first answer to a bigger question: what should computing look like when AI becomes an active participant, not just a chatbot?

Most AI products never ask it. They treat the model like an oracle. You bring a question, it brings an answer, and then you go do the work. The AI participates in your thinking but not in your computing. It lives in a text box, sealed off from your files, your tools, your actual life.

That was fine when models were mediocre. But by late 2025 they could write working code fluently, reason through multi-step problems, and plan. And the standard experience was still: ask, receive text, do it yourself.

That gap wasn't a model problem. It was an operating system problem.

"Windows made computing click for humans"

Here's the framing we launched with, word for word:

Windows made computing click for humans. Taku makes computing click for AI.

Computers were powerful long before 1985. But that power was locked behind a command line, usable only by the small tribe willing to memorize incantations. Windows didn't make computers smarter. It made their existing power accessible.

In 2025, AI was in its command-line era. Enormous capability, locked behind interfaces that either did too little (chat) or demanded too much (developer tools).

So Taku 1.0 made a claim that sounded arrogant at the time: we called it the first OS built for AI.

Not an assistant. Not an app builder. An operating system, because what AI needed wasn't a better chat window. It needed what any capable worker needs: tools, permissions, and somewhere to actually execute.

The loop we shipped:

Thinks → Builds the tool it needs → Runs it for you → You reap the reward.

Notice the third verb. That's the one nobody else was doing. Chat assistants, AI app builders, code editors: every alternative stopped at the same place, the moment the code exists but doesn't run. Our whole bet was that this moment, not model quality and not prompt engineering, was where AI's value to normal people was leaking away.

At the time, we put it provocatively: vibe coding is dead. What we meant was narrower and, I'd argue, correct. Vibe coding as a destination was dead. Generating code and calling it done was dead. Generation only matters as the first step of a loop that ends in execution.

Then the whole industry agreed with us

Here's the part I enjoy telling.

In the nine months since Taku 1.0, the most important AI products in the world converged on the same architecture.

Claude Code and OpenAI's Codex, the two flagship agentic coding tools, are both at their core a model wired into an environment: file access, tool-calling, permission to execute what it writes. Not chatbots. Agents with an operating context.

Agentic workflows went from a research phrase to a product category. The standard advice for building with AI stopped being "write better prompts" and became "give the model tools and let it act." Even the protocols standardized, because everyone independently hit the same wall we described: a model without an environment is just an expensive text generator.

The thesis of Taku 1.0, that AI shouldn't just chat but should build tools, use tools, and execute tasks, stopped being contrarian. It became the roadmap.

We don't say that to gloat. We say it because it validates the question. Ask "what should computing look like when AI is an active participant?" honestly, and you keep arriving at the same answer: the model needs an OS.

What Taku 1.0 taught us

Three things from the first version still shape everything we ship:

1. People don't want code. They want outcomes. Nobody asking for a tool cares about the TypeScript underneath. The measure of an AI product is the distance between your intent and a running result, and every manual step in between is a tax.

2. Execution needs a place. An agent that can act needs somewhere safe and legible to act in: one interface where tools get built, run, and live afterward. Scattering that across a chat window, an editor, a terminal, and a hosting dashboard is how you lose everyone who isn't an engineer.

3. A tool that runs once is nice. A tool that keeps working is a product. The first run is magic. The tenth run, when it's just there and part of how you work, is the actual point.

That third lesson is the bridge to everything Taku has become since: not just an OS where AI builds tools for you, but a place where the best tools and setups travel between people. That's the next chapter, and it deserves its own post.

The takeaway

Taku 1.0 started with a simple belief: intelligence is only useful when it can act.

That belief hasn't changed.

What has changed is how much bigger we now think the opportunity is.

That's where Taku 2.0 begins.

---

Taku is available for macOS. Ask it for a tool you've always wanted, and watch it run.