pre-alpha · engine running on a real phone

The server room
in your cellphone.

Cellar turns any modern Android phone — no root required — into a rootless Linux server built to run AI agents: machines you tap to create, agent stacks you tap to install, schedules that respect battery and heat.

Get started Why a phone? ↓
Why a phone

The worst place to host a website.
A surprisingly good place to host an agent.

Phones lost the server wars for reasons that stopped mattering the moment the workload became an AI agent waiting on a model API.

Agents are network-bound

An agent harness spends >95% of its life waiting on model APIs. The overhead of rootless Linux — the thing that makes phone-hosted databases slow — barely shows up in agent workloads.

Phones know things no VPS can

Notifications, SMS, location, sensors, battery. Cellar's permission-gated bridge gives an agent your real-world context — off by default, audit-logged always. That's the feature no cloud box can copy.

Already on, already yours

8–16 GB of RAM idling in your pocket 22 hours a day — and the retired phone in your drawer is a free, always-plugged server with a battery for a built-in UPS.

How it works

A boring engine under a friendly face.

One static Go binary drives proot machines — full Linux distros in your pocket, no root, no VM, no telemetry. The app is a frontend; everything it does, a terminal (or an agent) can do too.

Machines

Real distro rootfs images, sha256-verified, one command (or tap) each. Start daemons detached with logs; stop, export, delete. Read commands speak JSON.

Agent catalog

One-tap stacks: claude-code, python-uv, node, sshd — with local models and MCP kits on the roadmap. Idempotent, shellcheck-gated, honest about footprints.

Keys done right

API keys live in Android Keystore, injected as env vars at start, never written into a rootfs, never included in an export. (Today: -e KEY=... on the CLI.)

Watt-first schedules

“Run my research agent at 2 a.m., only while charging, only under 40°C.” Heat and battery aren't bugs here — they're first-class scheduling inputs. (Planned — ships with the app.)

Honest by design

What Cellar deliberately is not.

Every “Linux on your phone” pitch dies the moment it overpromises. This section ships with the product.

Not hosting

Phones reboot, overheat, and leave the house. Cellar is a personal lab — agents run as scheduled bursts, not five-nines daemons, and the UI says so.

Not multi-tenant

Everything runs under one Android UID. Machines organize your work; they don't defend against hostile code. Run things you trust — real VM isolation arrives if/when Android's AVF opens up.

Not magic

proot taxes syscall-heavy work, Android kills greedy background processes, and 24/7 serving cooks phones. The docs list every constraint and the engineering that answers it.

Quickstart

Six commands to your first agent.

The engine runs today under Termux, before the app ships. If you can install an APK, you'll manage this.

# one-time setup
$ pkg install proot golang git
$ git clone https://github.com/Airn0x/Cellar # source opens with the beta
$ cd Cellar/engine && go build -o cellar .

# a Debian machine with Claude Code inside, on your phone
$ ./cellar create dev --distro debian
downloaded 90.3 MB, sha256 ok
machine "dev" ready (debian trixie)
$ ./cellar apply dev claude-code
$ ./cellar exec dev -e ANTHROPIC_API_KEY=sk-… -- claude -p "hello from my phone"
FAQ

Asked early, answered honestly.

Do I need root?
No. Cellar is built on proot — userspace fake-root that works on every stock Android phone. That's also its main limitation: no kernel namespaces, no real containers, no ports below 1024. The plan explains the trade honestly.
Is this Termux?
Cellar stands on the shoulders of the same giants (proot, the Termux ecosystem) but tells a different story: machines, an agent catalog, key management and schedules instead of a package manager and a prompt. Today's engine runs under Termux; the app will need neither Termux nor a terminal.
Can it really run AI agents?
It already does: Claude Code installs from the catalog and runs inside a Cellar machine on a stock, unrooted Android phone — that's the standing test rig. Agents are network-bound, so the rootless-Linux overhead mostly disappears. Local small-model inference (llama.cpp) is on the roadmap as a charging-only mode.
What about my battery?
Watt-first is a design rule: heavy work is meant for the charger, the planned scheduler will treat “plugged in” and temperature as conditions, and the dashboard will show thermals as prominently as CPU. A retired phone on a charger sidesteps the question entirely — and that's the recommended way to run Cellar 24/7.
Where's the source?
MIT-licensed and opening with the beta. The engine is being hardened first: CI (vet, tests, shellcheck), multi-lens code review, and on-device integration runs on a real phone — see field notes for the Android war stories. Watch this page.
Play Store?
We'll try. Apps that execute downloaded code live in a policy gray zone — so F-Droid and direct APK releases are first-class citizens from day one, not a fallback.