Free + open source · Local control plane · BYO CLI

Your project folder becomes the AI control plane.

Alepou wraps Claude Code, Codex CLI, Gemini CLI, and shell in a project-owned workspace. Memory, plans, tasks, command approvals, bridge snapshots, and git-linked audit history stay as inspectable files beside your code.

BYO CLI · no API keys · not SaaS · works with your existing subscriptions

Download for Windows GitHub
Interactive product tour
Hover to preview. Click to pin.
Alepou
Control Center
local runtime plain files
Projects
12 indexed
Projects 12
Sessions 7 live
Ports 5 tracked
M

my-app

D:\Sites\my-app

my-app main 3 sessions 2 ports
Git Backup
Managed Sessions 3
Session Mode Ports
a18f2b01 claude :3000, :5173
c44bd102 codex :3000
p77e0c14 planner -
External Terminals 2
pwsh.exe PID 11484 · project match
cmd.exe PID 11228 · detached run window
Project Ports 2
127.0.0.1:3000 LISTENING · preview live
127.0.0.1:5173 LISTENING · vite hot reload
A

api-server

D:\Services\api-server

api-server feature/auth-fix 2 sessions 1 port
Git Backup
Managed Sessions 2
Session Mode Ports
8f1da901 claude :8788
9cb82e30 shell -
External Terminals 0
No external terminals detected.
Project Ports 1
127.0.0.1:8788 LISTENING · agent server
D

docs-site

D:\Sites\docs-site

docs-site main 0 sessions 0 ports
Git Backup
Managed Sessions 0
No managed sessions running.
External Terminals 0
No external terminals detected.
Project Ports 0
No project-mapped ports detected.
Terminal Sessions
3 open
claude code
my-app · attached session
active 34% context
$ claude
reading auth/token.js
401 and 403 are being handled the same way.
patching refresh handler and request retry flow now.
---------------------------------------------------
planner t-012 active
fix token refresh [in progress]
add rate limiting [pending]
write migration [pending]
Preview
2 ports live
localhost:3000 localhost:4173
http://localhost:3000 live
customer dashboard Preview what the code is doing right now.
Settings
desktop runtime
Connection Agent Base URL

http://127.0.0.1:8788

Safe mode and auto-refresh are controlled here.
Backup Snapshot root

D:\Backups\Alepou

Snapshots store commit, branch, dirty state, and note.
Runtime Tracked ports and unmatched processes

See what is actually alive, not just what you launched.

:3000 web preview :8788 agent server 2 external shells detected
CLI Settings
per-model defaults
Claude effort: medium

permission presets and custom auto-approve patterns

Codex gpt-5.4 · xhigh

model, reasoning effort, and Windows sandbox defaults

Gemini preview features

toggle experimental capabilities without leaving the app

Workspace
6 connected subviews
website-tour-workspace.md
EditPreview
Send to CLISaveDelete
ComposerProject Inbox
Kind
Title
Detail
Use detail for anything longer than the title.
ListInbox items (0)
EditorProject Setup (Important!)
plan/inbox/project-setup-important.md
Kind
feature
Status
open
Title
Project Setup (Important!)
Detail
I opened Gemini in a brand new project and he had no idea how to do anything. Because there was no existing folder structure in that project. I think it is absolutely essential that when we open a new project that our software creates the needed folder structure with all the files in place, including any expected file structure or metadata so the CLI knows exactly how to actually use it.
Saved
AI SessionCLI
claude code · p77e0c14
Planner attached to my-app. What would you like to work on first?
Ready · planner attached to the same local project context
Task boardTask Board 76
showing total tasks · file-backed in plan/tasks.json
New task title...Description (optional)Category
t-067 workspace architecture and subview modelplanner
Rebuild the workspace scene into a nested internal workspace.in progress
depends on t-035, t-071, t-072deps
t-068 Docs and Inbox fidelity passplanner
Match the docs rail, editor, composer, list, and detail layout from plans.html.pending
depends on t-067deps
t-069 command center fidelityqueued
plan/tasks.jsonwaiting on workspace pass
Audit trailHistory git-backed
one task → one commit → SHA on the task entry
Today 3 commits
t-212 phone DOM fidelity pass Codex
a1286f9 +214-38 4 files · click for the full diff
t-211 command center live health Claude
f455d40 +96-12 2 files
t-209 watchdog stall classification Gemini
9d88f1c +58-7 1 file
Yesterday 2 commits
t-206 release gate checklist pass Claude
3ae7dcd +31-4 1 file
Revert

Roll back any task commit from here — gated by typing CONFIRM, never by one stray click. The rollback itself becomes a new commit, so the trail never loses an entry.

WorkersLive health + automation state
Selected tasksRun state
Execution logAppend-only project trace
Supervisor transcriptDecision trace stays visible
DeliberationRound 1
ClaudeCodexGeminiSupervisor
Ask one question to the room. Claude, Codex, and Gemini each answer the same prompt, then the supervisor synthesizes.
Round ready · transcript will be saved under plan/deliberations/
Each participant answers the same question before synthesis.
Product tour 5 chapters
01Projects
M
my-app
main3 sessions2 ports
Claude Codex Gemini ▶ Run Workspace

Start from the project, not a pile of terminals.

Each codebase gets its own card — launchers, live sessions, ports, git, and backups grouped under the right repo.

02Terminals
claude code gemini cli codex cli
$ claude
reading auth/token.js
patching refresh handler and retry flow now.
fix token refresh [in progress]

Claude, Codex, Gemini, and shell — embedded and project-bound.

Sessions stay attached to the right repo, named and reachable — from the desktop or the phone remote.

03Workspace
DocsInboxAITasksHistory
Plan the auth refactor and queue the tasks.
Three tasks filed on the board — t-101 is ready to dispatch.
Type your planning message…Send

One agent wrapped in memory, plans, tasks, and docs.

File-backed planning lives beside your code under plan/ — continuity from session to session, nothing hidden in SaaS memory.

04Command Center
supervisor · Claudereviewing diff · t-211
worker · Codexexecuting t-212
3 / 5

A supervisor assigns tasks; workers execute and commit.

Sequential or parallel runs on the subscriptions you already have — every completed task ends in a git commit, the watchdog catches stalls.

05Deliberation
ClaudeCodexGemini
Claude Ship the release gate before new features.
Codex Agreed — tests first gives confidence.
supervisor synthesis · round 2

Three models answer independently, then converge.

One question goes in once; Claude, Codex, and Gemini answer without seeing each other, then a supervisor synthesizes the strongest plan.

Why it is different

The control plane stays yours.

Cursor, Windsurf, and Antigravity are editor-first agentic environments. Alepou is different: it is a local workspace around the CLI tools and project files you already use.

Claude Code, Codex CLI, Gemini CLI, and shell sessions stay as real local processes. Alepou groups them by project and gives them file-backed plans, memory, inboxes, and tasks — one connected agent working in a project-owned workspace. When you want to scale, a supervisor model can keep the queue moving while workers execute in their normal terminals.

A newer wave of agent orchestrators — Conductor, Superset, Agent Deck — groups the same CLIs behind parallel worktrees and run dashboards. Alepou's model is different: one task, one commit, in your real working tree, with memory, plans, and audit history as plain files in your own repo. When Vibe Kanban shut down in April 2026, its users had to migrate their workflows out. If Alepou stopped tomorrow, everything it knows would still be sitting next to your code.

You keep your editor. You keep your official CLIs. You keep your subscriptions. Alepou gives the surrounding workflow a local control plane.

Fresh sessions should not start cold.

Alepou keeps project memory, tasks, plans, and handoffs in local files, then gives the model a bounded map of the current state when a session starts. The goal is not to stuff more into the prompt; it is to stop wasting context on rediscovery.

Read the full comparison
Context-directed

Starts each workspace session with a bounded map of the project instead of making the model rediscover it.

CLI-native

Wraps official CLIs instead of replacing them.

Local-first

Project files and planning state stay on your machine.

Project-aware

Sessions, tasks, docs, memory, ports, Git, and backups live under the same project.

File-backed

Plans and task state are plain files, not hidden service memory.

Tool-bridge ready

Domain tools can export local state, accept approved command files, and report results back into the same planning center.

Audit-grade history

Every completed task ends in a git commit, with the SHA recorded on the task entry. Click through to inspect the diff.

Shutdown-proof

Plans, memory, tasks, and history are plain files and git commits in your repo. Nothing to migrate out of, ever.

Scales when ready

Supervisor and worker queues are built in for when one agent isn't enough — opt-in, not the default posture.

Phone-continuous

Monitor and manage the same live sessions over LAN or Tailscale.

What it actually does

Everything that was missing
from the CLI.

Multi-session workspace
Claude Code, Codex CLI, and Gemini CLI in one window, organised by project. Per-tab launch presets for continue, resume, fork, and worktree. Switch projects without losing your place.
Planner and task board
A planning assistant powered by your connected CLI session. The AI writes structured replies into project files rather than terminal noise — keeping dialogue clean and searchable while the terminal stays focused on execution logs. The task board is file-backed and AI-maintained: the model externalises work onto it, moves tasks through states, and records the git SHA on every completion. Project inbox and documents are plain files, version-controlled alongside your code. No SaaS, no sync layer, no hidden memory.
Auditable AI work
Every completed task ends in a git commit, and the commit SHA is written back to the task entry. The task board doubles as an index of every AI-completed change in the project. Click any completed task to open its diff in-product — files changed and exact line additions and removals, sourced from real git show output. The audit trail is plain git in your own repo, so git log, git revert, git blame, and CI hooks all apply as-is. A dedicated History tab shows the day-grouped timeline of every AI commit — click any entry for the full diff, revert with a typed confirmation.
Context efficiency
Large context windows still need direction. Alepou keeps durable project state outside the model and passes a bounded, relevant map into each new workspace session, so the model starts with the task board, memory, plans, and handoffs that matter.
Supervisor orchestration
Build a task list, assign a supervisor model, attach a worker, and let it run. The supervisor reads your plans and project memory, assigns tasks with precise instructions, reviews each git diff, and advances the queue — without you in the loop. One supervisor and one worker is enough: only one model runs at a time, so your existing subscription handles it.
Watchdog automation
Every terminal in an orchestration run is monitored for unexpected inactivity. If a worker stalls — permission prompt, unhandled error, anything — the watchdog detects it and alerts the supervisor. Runs do not silently fail overnight.
Project runtime state
Processes, ports, detected URLs, and deployment status. Not just what you launched, but what is alive right now for each project.
Snapshot backups
Checkpoint with a note before a risky change. Store branch, commit, dirty state, and timestamp. Restore later without git gymnastics.

Audit trail

Every AI change,
accountable.

Every tool in this space will eventually face the same question from a security review or a compliance office: “Show me every change the AI made, who approved it, and undo the third one — without losing the record.” Alepou is built so that question has a boring answer.

Attributable

Each completed task records which agent did the work, and the commit SHA is written back onto the task entry. git blame resolves to a task, an agent, and its planning context.

Contemporaneous

The record is created by the completion flow itself — commit first, SHA onto the task — not reconstructed later from chat logs.

Reversible without erasure

Undo requires a typed confirmation and lands as a new commit. The trail is append-only: the rollback is itself an auditable event.

Plain git underneath

No proprietary history store. git log, git show, CI hooks, and your existing review tooling inspect the AI's work with zero adaptation.

Alepou is not a validated compliance system and does not claim to be one — but teams in regulated environments will recognise the shape.

Unity Bridge beta

Alepou can bridge the tools around your code.

Unity Bridge is the first domain bridge for Alepou: a local package that lets AI CLI sessions see the Editor — scene state, a queryable asset index, Console output, even Scene and Game view captures — and change it through 28 approved command actions, while the planning center stays in charge.

01

Unity exports state

Scene hierarchy, selection, Inspector snapshots, Console output, a queryable asset index, packages, build settings, diagnostics, compile status, and command results are written into plan/unity/ — and refreshed automatically as the Editor changes.

02

The AI writes intent

The CLI writes C# scripts as normal assets, then creates explicit command JSON under plan/unity/commands/pending/ for scene and Inspector changes.

03

Unity approves and applies

The Editor window previews pending commands. You approve them locally — or allow-list trusted actions for auto-approval — and Unity applies them through Unity APIs with Undo grouping, then writes applied or failed results.

04

Alepou keeps the run coherent

The planner captures the Scene or Game view to see the result, inspects command outcomes before continuing, updates tasks, and keeps the same audit trail: local files, explicit decisions, and git-backed completion.

Unity Package Manager https://github.com/alepou-ai/alepou.git?path=/terminal-manager/unity-bridge/com.alepou.unity-bridge#unity-bridge-v0.5.0

It is not a shift into being a Unity-only product. It is a proof point for a broader pattern: expose local tool state, use approved command files for side effects, and let Alepou remain the planning center for the whole project.

Phone remote

Your project follows you.

You started a refactor at your desk. Your phone shows you it is still running and lets you steer from wherever you are.

  • + Pair by scanning a QR code
  • + Open projects and launch sessions
  • + Message the planner and check the task board
  • + Monitor and steer active orchestration runs
  • + Stream live terminal output
  • + Browse docs and manage backups
  • + Works over LAN or Tailscale

Phone remote is a paid companion app — $2.99 one-time, coming to Google Play. Desktop core is free and open source (Apache 2.0).

Deliberation and orchestration

One supervisor. One worker.
The task list never stops.

The 1+1 setup is the sweet spot: Claude Opus reads your context and assigns the next task. Codex executes, commits, and says done. Supervisor reviews the diff and moves on. Only one model runs at a time - subscription-friendly, without running multiple model sessions at once.

Deliberation

Send one question.
Get three independent answers.

Round 1: each model responds without seeing the others. Round 2 onward: each sees the full transcript and refines. A supervisor synthesizes agreements and open questions. Iterate until consensus, or a clear disagreement that tells you something real.

The architecture of this product was designed using deliberation mode. Three models debated structure and tradeoffs across multiple rounds before any code was written.

Orchestration

Queue the work.
Step away.

The supervisor reads your project memory and task board, writes precise instructions for the worker, and dispatches. The worker executes and commits. Supervisor reviews the git diff and assigns the next task. Repeat until the queue is empty — or the watchdog fires because something went wrong and needs your attention.

Add more workers for parallel throughput. On subscription, 1+1 is the practical sweet spot. For larger overnight runs, per-token API keeps costs predictable.

License Apache 2.0
Architecture Local-first · Your code stays on your machine
Model access Official CLIs · Subscription-safe · No API keys through Alepou
Product type Local app · Not SaaS