Local models, on your own machine

A desktop app for a fully local model stack.

dai is the calm front end for bonsai: chat, agentic coding, deep research, vision, memory and self-improving skills, running on your own consumer GPU. No cloud, no accounts, no telemetry.

Get dai The stack Install

Chat. The theme above follows the toggle, top right.

What it is

One quiet surface for the whole local stack.

Two modes switch from the sidebar. Chat streams a conversation with the local orchestrator: markdown, code copy, image attach, an effort dial and an ultra toggle that fans a task out to contained sub-agents. Code is session-first agentic work with a plan, a file tree, diff previews and confirmation cards for every shell command and file edit.

Deep research

A quiet switch turns a message into an async research job. Coarse progress renders inline, then the cited report lands as markdown. Web search is pluggable.

Projects and schedules

Group sessions with a plain-text knowledge base, or set a prompt to run daily, weekly or on an interval. Recents stay separate for chat and code.

Memory and skills

Local SQLite recall, an editable identity, a skills creator, and import of agentskills.io skills from openclaw or Hermes. Nothing leaves the machine.

System panel

Live residency state, VRAM per GPU, the KV-cache and TurboQuant config, quant family and every server notice, shown verbatim.

The stack

Four small parts, coordinated by a frozen contract.

dai talks to one local server over plain HTTP. Every piece is an independent, Apache-2.0 repository.

suiban

The inference and orchestration core. Runs the models, plans a VRAM-aware loadout, drives the agentic loop, keeps memory and skills.

github.com/YKesX/suiban

dai

This desktop app. Tauri, React and TypeScript, with a design language of ink on warm paper.

github.com/YKesX/dai

sentei

The coding-focused terminal client. Streaming output, confirmations, session resume and a reboot-surviving service.

github.com/YKesX/sentei

SLAP

The Structured Lightweight Agent Protocol. A versioned, schema-validated format for orchestrator-to-worker coordination.

github.com/YKesX/SLAP

Under the hood

Built to be cheap to run and honest about what it does.

Lazy keep-alive

The server starts holding no VRAM. Models load on the first request and release after an idle timeout, ollama-style. Always-on costs nothing until you call it.

TurboQuant KV cache

A 4-bit V-cache built as new GGML types, runtime-validated on an 8 GB laptop with perplexity inside the q8_0 baseline and needle retrieval passing.

SLAP multi-agent

Ultra runs coordinate sub-agents with validated protocol messages. The orchestrator writes each worker a volatile system prompt that dies when the agent finishes.

Private by default

Loopback bind with no auth on your own machine, a bearer token the moment you expose it to a network, and untrusted web and file content fenced away from the tools.

dai system panel showing residency, VRAM and the loadout

System. Residency state, VRAM and the live loadout.

Install

Two commands to a built app, one to run it.

dai needs a local suiban server. Install it alongside, or point dai at one running elsewhere.

git clone https://github.com/YKesX/dai && cd daiClone the desktop app.
./install.shnpm install, then a production build.
npm run tauri buildPackage the click-to-launch app. Needs the Rust toolchain.

# the local server, in its own clone
git clone https://github.com/YKesX/suiban && cd suiban
./install.sh && uv run suiban install binaries && uv run suiban install models
uv run suiban serve   # http://127.0.0.1:8686

Honest limits

Everything above is measured on a single RTX 3070 Ti Laptop, the 8 GB tier. Windows and macOS installs are coded and name-verified but not run end to end. WhatsApp linking renders a real QR but the live send path is not yet wired. Each repository ships a KNOWN_ISSUES file that says so plainly.