An Open Kernel for AI Agents
Two schemas, a conversation loop, a hook system, a cascade engine, an extension loader, and a response protocol. The minimum kernel an AI agent needs to live somewhere persistent, think at every position, communicate through signals, and grow through extensions. Plant the seed. Build anything on top of it.
TreeOS is the first operating system built on the seed. It ships with 25+ extensions.
The seed is the kernel. It defines the data contract, the conversation loop, the hook system, the cascade engine, the extension loader, and the response protocol. It never changes. It never imports from extensions. It boots clean with zero extensions installed.
TreeOS is one implementation built on the seed. It ships with extensions for AI modes, tool definitions, billing, federation, HTML rendering, and more. But those are all extensions. Someone else could build a completely different system on the same kernel. A medical platform. A code review pipeline. A research assistant. The seed provides structure. Extensions provide meaning.
Same relationship as Linux and Ubuntu. The kernel is the contract. The distribution is the interpretation. TreeOS is the first distribution. The seed is what we are giving to the world.
Two schemas (Node and User), an AI conversation loop, five registries (hooks, modes, orchestrators, socket handlers, auth strategies), a cascade engine, and a response protocol. Lifecycle hooks covering every critical moment from node creation to AI response to cascade signals. The part that never changes. Build on it.
Everything else. AI modes, tool definitions, billing, HTML rendering, fitness, food, scripts, wallets, gateways, dreams, understanding. Install what you need. Build your own. Each extension adds commands, tools, hooks, and AI behavior. The tree controls what is active at every position.
Every land is sovereign. You run yours. Someone else runs theirs. Lands peer directly through signed requests. Share trees, proxy LLM calls, propagate cascade signals. The Horizon helps lands find each other. Anyone can run their own Horizon.
Six pages. Each one answers one question.
What is the contract?
How does the tree think?
How does the tree communicate?
How does data move?
How does the tree grow?
How do trees connect?
The land is the ground. Trees pull signals from .flow like roots pull water. The AI at each node transforms raw input into new structure. The tree grows from what flows through it. Cascade connects the seed to extensions to federation. The nervous system running through all three layers.
The CLI works like a regular terminal. cd, ls,mkdir, rm, mv. If you know a shell, you know TreeOS.
Where you are determines what the AI can do. Navigate to change context. No mode switching. Just cd.
/The root. Manage extensions, configuration, users, peers. The AI becomes a land operator. It can install packages, read system nodes, run diagnostics, and manage federation. Admin access required.
~Your personal space. Raw ideas, your notes across all trees, your chat history, your contributions. The AI helps you organize and reflect on your work across the whole land.
/MyTreeInside a tree. The AI reads the branch, classifies your intent, and acts. Chat reads and writes. Place adds content silently. Query reads only, changes nothing. Extensions like fitness and food add their own commands and AI behavior that activate on the branches where they're allowed.
Your server. Stores trees, runs AI, serves the API. First boot walks you through config and extension selection.
treeos landPoint the CLI at any land. Register. Connect your own LLM or use the tree owner's model.
treeos connect http://localhost:3000Name it. Type it. Navigate with cd and ls. Build branches with mkdir. Add notes (text or files).
treeos mkroot "Fitness" --type goalChat creates and edits. Place adds content where it belongs. Query reads without changing anything. You and AI work the same tree.
treeos chat "break this into weekly tasks"npm let developers stop rewriting the same JavaScript functions. TreeOS does the same thing for agent orchestration. Instead of sharing code that humans run, you share capabilities that agents run, on a persistent structure that agents inhabit.
Every extension is a piece contributed toward the future of AI infrastructure. There are many things to be built off the kernel. Open code, open doors, resilient, decentralized. This was designed to be held back by no one.
Navigate somewhere and the world changes. Each branch controls which extensions are active. Block an extension and it disappears for that entire subtree. Restrict it to read-only and it can observe but not modify.
The fitness coach can reference your nutrition data (it's read-only there). The food coach can't create workout nodes. Each branch controls its own capabilities. Same extensions, different access, based on where you are.
A modular runtime for persistent AI agents with a federated extension system. The kernel manages tree-structured data and an MCP-based AI loop. Extensions register their own tools, routes, models, and jobs.
Every orchestration pattern you build dies in your repo. TreeOS makes orchestration composable and shareable. Package your memory system, your reasoning chain, your tool pipeline as an extension. Publish it. Now every agent on the network can use it.
The internet was built for documents. AI agents need persistent structure, memory, tools, and the ability to interact with other agents. TreeOS is what the internet might look like if it were designed for agents from the start.
The Canopy Protocol is how lands discover and peer with each other. Lands advertise their loaded extensions. The foundation for capability-aware federation where agents can navigate between lands, carrying context and discovering what tools exist at each destination.
Direct land-to-land connections. Signed requests.
Search lands and public trees across the network.
Cross-land invites. Remote contributions. AI proxy.
Publish and pull extensions. Shared package library.
Those are products where you visit an AI in someone else's house. TreeOS is infrastructure where the AI lives in yours. The agent persists. It accumulates context. It gains capabilities through extensions you choose. It federates through an open protocol. It is not a chat product. It is the layer beneath chat products.
A model is a brain with no body. TreeOS is the body. The persistent structure, the memory, the tools, the network. It is model-agnostic. The kernel runs an AI conversation loop via MCP. What model powers it is your choice on your land.
One package. Two commands.