Most of us juggle a dozen apps to get through the day: one for notes, one for chat, one for files, one for the to-do list. None of them really knows what the others know, so you spend half your time copying things from one to the next and wondering which version is the current one.
KOA is the opposite bet. It's one shared place where the work lives — and both a person and an AI assistant can read and write the same thing there. You don't message a chatbot and copy its answer somewhere else; the assistant works inside the same files, notes, and tasks you do. Think of it less like a smarter chatbot and more like an office that an AI happens to share with you.
One place for the work
Notes, tasks, code, and records all live together — on your laptop, a Mac, or pulled up on a phone. No hunting across apps.
It doesn't forget
Decisions and progress are written down in plain text and kept. Pick up a project weeks later and the context is still there.
Helpers that can act
AI assistants don't just answer — they can draft, file, fix, and tidy up, with you approving the changes that matter.
=======Meet koa-cli — The Studio's TUI Agent
Our personal agent and developer companion. Built with Python and Textual, koa-cli integrates deeply with our git monorepo, koa-todo task manager, and local markdown memories. It features inline diff approvals, a collapsible tool execution panel, and a live reactive ASCII mascot.
⌨️ Command-Line Native
Launches instantly via koa or koa chat. Full-screen TUI with syntax highlighting, live streaming tokens, search filters, and ctrl+k command palette.
🐨 Reactive Mascot
Our half-block ANSI-art purple koala mascot lives in the sidebar, changing facial expressions and animation states (thinking, writing, success, error) dynamically.
🛡️ Interactive Consent Gating
Diff-based approvals for file updates and bash commands. Cycle permissions dynamically from default to accept-edits or plan.
🧠 Monorepo Conscious
Automatically respects submodules and branch worktrees using koa-branch. Deep lookup inside 06_data/koa-memory/ indices.
Under the hood, KOA isn't one big program — it's dozens of small parts, each doing one thing, glued together so that people and AI agents share the same workspace, the same memory, and the same way of shipping changes. Here is what that buys, in four ideas.
Workspace, not chat
One git repo, four nodes, a sync script. Agents and humans edit the same files. No copy-paste between tools.
Durable memory
State and decisions live as Markdown in the repo, not in vendor databases. Anything important survives sessions.
Small parts, plain protocols
FastAPI services, systemd units, SQLite, plain HTTP. Easy to read, easy to replace, easy to debug.
Agent-friendly by default
Every service ships with a public health endpoint, a JSON shape, and an llms.txt. Agents are first-class users.
Workspace & sync
Filesystem layerOne canonical copy of the studio, kept in lockstep across every machine we run on. Change something on one node and the rest see it on the next sync — no copy-paste, no “which version is current”.
Underneath: a git monorepo with submodules, rsync over a private mesh, per-service deploys that always end with a smoke test, and a one-command bootstrap for a fresh node.
Memory & context
State layerThe studio's working memory. Every decision, snapshot and session note is written to plain text in the repo, so anyone — human or agent — can pick up where the last one left off.
Single-writer state files, append-only session logs, periodic auto-checkpoints, context guards that gate which directories any agent may read, and an Org-roam graph daemon that exposes the whole thing as a queryable API.
Agent layer
LLM plumbingThe agents themselves, and the wiring that lets them call tools, share prompts, and reach the outside world through one well-defined door.
A personal agent with a tool catalogue and access policy, an MCP server for other clients, an OpenAI-compatible router that tracks cost across providers, a versioned prompt library, and a single audited gateway with API-key auth and rate limits.
Events & comms
Message layerHow the system talks to itself, and how a human on a phone talks to agents running on a server somewhere. Small, plain, no platform lock-in.
An agent-friendly link relay with auto-restore from gzip backup, and a bidirectional chat-to-Markdown bridge with a Mattermost adapter, both routed through a single audited gateway — so the conversation log is owned in the repo, not in a vendor.
Infrastructure & ops
Node layerThe boring stuff that must never fail: backups, DNS, and knowing what is running where.
Nightly local + offsite snapshots of databases and state dirs, a single inventory of every domain and registrar, a generated catalogue of running services with healthchecks and owners, and bootstrap scripts for tiny edge nodes (Raspberry Pi class).
Hub & generation
Surface layerWhat we look at every day, and how we scaffold new things — so “start a new service” takes minutes, not days.
Studio dashboard with live status tiles and an operational panel for metrics and costs, a DB-backed task store as the single source of truth for pending work, and a pattern-based generator that writes a working baseline for any new service from a catalogue of reusable recipes.
koa-cli
Tool · BetaThe one piece of KOA that stands on its own: the terminal agent we use to drive everything above. Streamed replies right in your shell, an interactive interface with a live koala mascot, and approve-before-it-writes diffs for every change.
KOA is shaped around one operator's workflow. It is load-bearing for our own studio — opinionated, in-house, and still moving fast. We talk about it openly because the ideas are reusable — small services, plain text memory, agents as first-class users, one canonical repo across nodes — and pieces open up as they mature. The current implementation is tight enough to ourselves that it would mostly get in your way today.
If you want to build something similar for yourself, the studio is open for that kind of work.