AI models will change. Providers will change. The work, the decisions, and the history of what happened should remain yours — as plain files and ordinary Git in the repository you already own.
local-first · file-backed · CLI-native · model-flexible · auditable
Six convictions
Plans, tasks, memory, summaries, and hand-offs sit beside the code as inspectable files — not in an opaque chat history or a vendor database. One folder holds everything the AI knows about the project.
Use the strongest model where judgement matters. Use cheaper, open, or local workers where execution is bounded. The project — its memory, tasks, and history — should not have to change when the worker does.
A large context window is not project memory. Alepou starts each session with a bounded map of the decisions, tasks, and hand-offs that matter, instead of asking the model to rediscover the project — or making you re-explain it.
A completed task ends in a git commit, and the SHA is written back to the task entry. Review the exact diff, revert with confirmation, trace any change back to the task and the agent that made it. The record is ordinary Git, not a screenshot of a chat.
Supervisors, workers, tasks, prompts, interruptions, and recovery all have a place you can inspect. When a run stalls — a permission prompt, an unhandled error — the watchdog surfaces it instead of letting the run silently fail overnight.
Alepou is open source (Apache 2.0), and its durable state is plain files and plain Git in your repository. If the app disappeared tomorrow, your plans, memory, task history, and audit trail would remain readable by ordinary tools.
The useful unit of AI work is not the chat. It is the project: its goals, decisions, tools, changes, failures, and memory.
The test
Not the important part. The code remains in the repository. The decisions, tasks, memory, and agent evidence remain as ordinary project files. The history remains normal Git.
That is the standard behind every design choice here: not whether an agent can produce an impressive run today, but whether the work remains legible tomorrow — after a model swap, a reset, a provider change, or the disappearance of the tool coordinating it.
When Vibe Kanban shut down in April 2026, its users had to migrate their workflows out. There is nothing to migrate out of a folder of plain files.
The boundary that matters
Alepou is CLI-native. It is not a model API service and not an inference reseller — no API keys pass through it. It coordinates the work around the local CLI runtimes you choose: project context, task state, evidence, and recovery.
Real local processes using your existing subscriptions or keys. Alepou does not relay, meter, or own those calls.
Sessions, planning, task ownership, orchestration, watchdogs, and evidence — on your machine.
Memory, task state, hand-offs, commits, diffs, and reversible history — plain files in your repo.
What this looks like in practice
A quiet terminal, a lost session, or a permission prompt is part of the runtime problem — not a reason to throw away the context and start over. The watchdog detects stalls and the supervisor is told, with the run state on disk to resume from.
plan/.execution-log.mdEvery bounded task ends in a normal commit with its SHA written back to the task entry. Review the exact diff in-product, or revert the task with a typed confirmation — without erasing the record.
task → commit → SHA → diffThe model receives a bounded map of current project state — recent summaries, the task board, open hand-offs. Enough to orient it; the rest stays on disk until it is actually relevant.
memory / tasks / hand-offsFor a bridge like Unity, the model reads exported editor state and writes explicit commands. The tool approves, applies, and reports the result — the model never edits fragile internal files blind.
state → command → resultWhere this leads
Not every task needs the same model. Not every project can leave the machine. Not every team will accept the same provider, privacy posture, or cost profile. The workflow needs to survive those choices.
Alepou today is a local, CLI-native desktop product. The later stages below describe an architectural direction — not a claim that every runtime or deployment mode has shipped.
Real local sessions, a file-backed planner and task board, git-linked audit history, and supervisor–worker orchestration with watchdog recovery — on your existing subscriptions.
One model keeps the project-level picture while cheaper or open-weight models handle bounded implementation through provider-neutral runtimes. Same files, same protocol — and measured honestly before we publish claims.
Local inference and internal gateways as execution choices through the CLI runtime the project uses — without moving the project’s memory and audit history into someone else’s platform.
Shared approval rules, access boundaries, and stronger audit records. It starts from the same principle: the system of record remains the project, not the model vendor.
A different starting point
Alepou is an open, local control plane for people who want AI workers to be useful, replaceable, inspectable, and accountable over time.