Durable units of work
Tasks with a plan, a todo state and an outcome; missions the autopilot pursues across many of them over time.
Elowen
A personal AI agent that runs on your own hardware — one daemon, one database file, and every surface you reach it through.
daemon :4400 · web ui :4500
An agent with a memory,
a mandate and a boundary.
You talk to it; it plans, calls tools, edits files, runs commands and comes back with the evidence. What it remembers, which models it may use and how far it may go without asking are yours to set — not defaults chosen somewhere else.
Tasks, missions, autopilot Any provider you configure One SQLite file Per-user tools and models
- NODE.JS ≥ 22
- TMUX
- ONE SQLITE FILE
- SYSTEMD · LAUNCHD
- MIT LICENSE
The interface is
a conversation.
There is no workflow to assemble first. You describe the outcome, and the session carries what it needs with it: the active project, the tools your account may use, the memory it has kept and the decisions already made.
Stay in the terminal when you want speed, open the web dock when you want the whole system in view. Same agent, same history, same rules.
Meet the CLI →
Work with a state,
a plan and a record.
A long job is a task, not a spinner. It holds its plan, its todo state, the tools it called and the evidence it gathered — and it survives a closed tab, a dropped connection and a restart.
Tasks group into missions, and missions are what the autopilot pursues on its own. Nothing runs where you cannot look at it: read the diff, steer the next step, or stop it before a risky action.
TASKMISSIONOVERSEEROUTCOME
MISSIONOne accountable result
EXPLOREClaude PLANGPT VERIFYGemini Specialists,
not a longer prompt.
When a job outgrows one context, the agent delegates. Each sub-agent starts clean, receives exactly the instruction it needs, and can only ever narrow the permissions of the agent that spawned it.
They run on whichever models you allow — one to explore the repository, one to argue with the plan, one to verify the result — in parallel or as a dependency graph. What returns is a conclusion, not a transcript.
Agents and providers →The next conversation starts where the last one ended.
Elowen keeps what is worth keeping — decisions, preferences, environment details, the shape of each project — and brings a fact back when it becomes relevant, together with the reason it was kept.
Memory is a place you can open. Search it by meaning, group it, correct a fact that changed, delete what no longer belongs. Nothing is profiled where you cannot see it.
How memory works → WHAT IT KEEPS
- DECISION · 5/5
Database migrations are forward-only; a rollback is done with a new migration, never by editing history.
- PREFERENCE · 4/5
Tests are written against behaviour and domain rules, never against internal implementation details.
- FACT · 3/5
Jordan owns the pricing domain and reviews anything that touches discounts.
Autonomy,
granted in degrees.
Projects decide where the agent may act. Roles and per-user policy decide who may ask, with which tools and which models. Autonomy levels and approval gates decide what may proceed without a confirmation, and an overseer reviews what runs unattended.
Provider credentials stay on the daemon and never reach a client. The same policy follows the agent into the CLI, the web UI and every connected channel — one runtime, one set of rules.
Read the access model →
- AUTONOMY
- ASK FIRST → AUTOPILOT
- GATES
- DESTRUCTIVE ACTIONS
- CREDENTIALS
- DAEMON ONLY
Same agent, same memory,
every surface.
The CLI when you want focus. The web UI when you want the whole system. Chat platforms when the work starts in a message somebody sent you.
CLIChat TUI, live tool output, task control and a REST passthrough, straight from your terminal.TERMINAL
Web UIDashboard, tasks, kanban, timeline, sessions, memory, projects, editor, terminal and settings.PORT 4500
ChannelsDiscord, Telegram, Microsoft Teams and WhatsApp reach the same runtime under the same policy.FOUR BRIDGES
Plugins & MCPAdd tools, channels and scheduled jobs, or connect an MCP server, without forking the core.EXTENSIBLE
Everything the agent needs.
One daemon on your own machine.
Delegation with clean context
Self-contained work handed to a fresh sub-agent — in parallel or as a dependency graph, on any model you allow.
Graded independence
From ask-first to unattended, with approval gates on risky actions and an overseer reviewing the runs.
Facts you can edit
Decisions, preferences and project context — searchable by meaning, categorised, correctable, deletable.
Repository-aware
Scoped working directories, semantic code search, inspectable diffs and a PR workflow with handoff notes.
RBAC down to the tool
Roles, per-user tools, models and projects, scoped API tokens, and gates on the actions that cannot be undone.
Work that starts itself
Recurring prompts and one-shot wake-ups, with cheap guard checks so a job only wakes a model when there is something to do.
Extensible to the core
Channels, tools and MCP servers load as plugins; repeatable procedures live as markdown skills the agent picks up on its own.
Already load-bearing.
Three live systems that would notice if Elowen stopped: a hair salon, an auto-parts counter, and this website.
Clients message the salon's Elowen on WhatsApp. It reads the calendar, offers the openings that really exist, confirms with an SMS code and sends the reminder the day before. Payments and expenses land in the books as they happen. The owner reads one summary in the morning and cuts hair.
Twenty-nine documentation pages, written, restructured and deployed by Elowen out of the same repository they describe. The orbital navigation you scrolled past was its own suggestion, ported from its web UI.
At an auto-parts counter, a supplier's delivery note gets photographed. Elowen reads the barcodes, matches the parts against the catalogue and books them into stock. An evening of typing became a few minutes of checking.
What you are actually running.
No control plane to operate, no managed service in the middle, nothing phoning home. Six pieces, all of them on hardware you own.
COMPONENTWHAT IT ISWHERE IT LIVES
Daemon The agent core: REST API on :4400, tool execution, the scheduler, the event stream and the channel bridges. Your host, Node.js 22 or newer.
Web UI A Next.js workspace on :4500 for watching and steering the agent. It holds no state of its own. Same host, behind your proxy.
CLI One binary: chat, setup, doctor, service control, task control and a REST passthrough. Your terminal, anywhere it can reach the daemon.
Database A single SQLite file holding conversations, memory, tasks, users and settings. Your disk, your backup, your migration.
Agent sessions Coding agents in isolated tmux sessions you can open and type into; sub-agents inherit narrowed permissions. Your machine, under your own user.
Model providers Any provider you configure — by API key, or by signing in with a ChatGPT or Claude subscription, with live usage meters. Credentials stay on the daemon.
From a bare machine to a running agent.
The bootstrap installs whatever the host is missing — Node.js, tmux, the services, optionally a reverse proxy with HTTPS — then creates the first admin and leaves a live web UI behind. Linux runs it under systemd, macOS under launchd as your own user, Windows inside WSL2. Prefer to do it by hand? The npm route and a Docker image are both documented.
LINUX · MACOS · WINDOWS (WSL2)NODE.JS ≥ 22 · TMUXSINGLE SQLITE FILESYSTEMD · LAUNCHD · DOCKERMIT LICENSE
$ curl -fsSL https://raw.githubusercontent.com/dragocz95/elowen/main/install.sh | bash
# Linux or macOS — Node, tmux, services, first admin
● Elowen is live — http://localhost:4500
$ elowen # opens the chat$ npm install -g elowen
$ elowen setup # guided onboarding wizard
● Web UI at http://localhost:4500$ docker build -t elowen .
$ docker run -d -p 4400:4400 -v elowen-data:/app/data \
-e ELOWEN_DB=/app/data/elowen.db elowen
# one SQLite file on the volume — an upgrade is a container swap# elevated PowerShell — enables WSL2, installs Ubuntu if missing
> irm https://raw.githubusercontent.com/dragocz95/elowen/main/install.ps1 | iex
● Web UI reachable from Windows at http://localhost:4500Common questions.
Where does my data live?
On your machine. Elowen is a self-hosted daemon with a single SQLite file — conversations, memory, tasks, users and settings never leave your infrastructure. Provider credentials stay on the daemon and are never handed to a client.
Which models can it use?
Any provider you configure — Claude, GPT, Gemini and others — by API key, or by signing in with a ChatGPT or Claude subscription you already pay for, with live usage meters for the rolling and weekly limits. Each sub-agent can run a different model, and an admin decides which models each user may reach.
Can it work unattended?
To the degree you allow. Autonomy runs from ask-first to autopilot, approval gates protect the actions that cannot be undone, and an overseer reviews what runs without you. Anything outside the granted scope stops and asks instead of improvising.
Can a team share one instance?
Yes. Role-based access control with per-user tools, models and project assignments, plus scoped API tokens for integrations. Everyone talks to the same runtime, each under their own policy.
What does running it in production involve?
A service behind a reverse proxy. sudo elowen install provisions a dedicated system user, the elowen-daemon and elowen-web units, optional Let's Encrypt HTTPS and an auto-update timer. A Dockerfile is available when you prefer containers.
Does it run on macOS or Windows?
Both. macOS runs entirely as your own user under launchd — no sudo, services start at login. Windows installs into WSL2: the bootstrap enables WSL2, installs Ubuntu if needed and runs the same Linux install inside it, with the web UI reachable from Windows at http://localhost:4500.
Is it open source?
Yes — MIT licensed, developed in the open at github.com/dragocz95/elowen.