Free + open source · Local control plane · BYO CLI

Your project folder becomes the AI control plane.

Alepou wraps Claude Code, Codex CLI, and Gemini CLI — plus a shell and any local CLI you add as a custom launcher — in a project-owned workspace. Memory, plans, tasks, Preview tabs for running local web apps, bridge snapshots, and git-linked audit history stay 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 local apps live
localhost:3000 localhost:4173
http://localhost:3000 live
customer dashboard Watch the running web app from the workspace.
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 — plus shell and custom launchers — 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.

A real run, condensed

Watch a supervised
run actually happen.

A real supervised orchestration run, trimmed from about 27 minutes to under four. The idle stretches are cut and captions explain each step, but the run itself is real and in order: nothing staged or reordered. A supervisor model reads the plan and task board, dispatches a worker, reviews each git diff, and advances the queue while the watchdog catches stalls. No human intervention after the run starts.

Real supervised run · one supervisor, one worker · ~27 min trimmed to 3:39 — waiting cut, nothing staged or reordered

Why the coordination layer is the cheap half of the bill

The supervisor spends almost all of its tokens reading — project memory, the task board, worker diffs, run state — and very few writing: short dispatch and verify decisions. On every model, input tokens are far cheaper than output — on current frontier pricing, generated output runs on the order of five times the price of input — and repeated reads are discounted further by prompt caching. So the expensive work, generating code, happens on the worker, which can run on a cheaper model or your own flat-rate subscription. The layer that keeps the whole run coordinated is structurally the cheap one.

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, and Gemini CLI sessions stay as real local processes — alongside a built-in shell and any other local CLI you add as a custom launcher. 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.

Local runtime surfaces

Preview watches running web apps, and shipped bridges expose local tool state 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.
Preview
A core local workspace surface for running web apps. Detected localhost URLs open inside Alepou so you can watch the app while CLI sessions edit, test, and restart it. It is a viewer for your local process, not hosting or deployment.
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.

One project-owned system

The control plane, the visual studio, and the Unity bridge.

Use Alepou on its own, add Canvas when the work needs a visual stage, or install Unity Bridge when the important project state lives inside the Unity Editor. Each surface remains local, inspectable, and independently useful.

Core · Windows desktop

Alepou

Manage real CLI sessions around one project-owned workspace: plans, memory, tasks, previews, orchestration, runtime state, and a git-linked audit trail.

Explore the control plane
Optional companion · open source

Alepou Canvas

Create websites, presentations, documents, interfaces, and games as structured visual projects. Design with AI, compile into editable elements, then keep refining on the canvas.

Explore Canvas
Unity package · beta

Unity Bridge

Give Alepou-managed agents bounded access to live Editor state, typed authoring, compile barriers, tests, builds, runtime capture, and separately granted Quest device work.

Explore Unity Bridge
Built with AlepouSee the finished work.Products and creative projects, with the human and agent contributions kept visible. Field NotesSee the method and evidence.Real runs, measured claims, failures, and what changed because of them.

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. As many workers
as the job needs.

Orchestration is for work bigger than one sitting: a supervisor model reads your plans and task board, dispatches workers, reviews every diff, and keeps the queue moving — overnight if needed. Workers on your existing flat-rate subscriptions add no marginal cost; add more in parallel when wall-clock speed matters.

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.

Honest note: a bounded job that fits one context window is often best served by a single strong session. Orchestration earns its keep when the queue outlives a sitting — endurance, parallelism, and watchdog recovery.

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