Spatial AI · Meta Quest 3 · Built by asking

Ask for an app and an AI builds it, straight onto your headset.

The headset runs one Alepou app that never changes. Each app — a lab procedure, a puzzle, a game — is a folder of plain files, built by AI agents (Claude, also Codex) in sessions Alepou supervises on your own computer. Swap the folder and the headset stays the same.

Meta Quest 3 · one client app · every app built on your PC

Coming soon Contact guy@varlis.io
Spatial AI, just ask: four headset apps, built by asking Claude2:16

Four spoken requests to Claude in Alepou, each answer cut to the app it describes, running on a Meta Quest 3. How it was made: the apps were built first; for the film the requests were asked again, and each answer cuts to that app’s own headset recording. Claude’s replies are spoken by the headset’s text-to-speech voice.

  1. 0:00An instrument procedure A balance eccentricity test
  2. 0:24A service procedure Pump-head seals on a Waters HPLC, labelled a demonstration
  3. 0:42A puzzle A Rubik’s cube solver
  4. 1:06A game, and a world Go against KataGo in a tea room
  5. 1:44How it works One headset app, every app a folder

The films

More films, one headset app.

Every app here runs on the same Alepou headset app. None of them is coded into it: each one is a folder of plain files that AI agents built on the PC.

Spatial AI in the lab

A balance eccentricity test, guided by Claude

One spoken request, and the headset guides an eccentricity test on a real analytical balance, read to 0.1 mg over USB. Claude holds the test until both hands are gloved, then checks the working and gives its own verdict: the front right read 0.8 mg below the centre, against a limit set strict on purpose at 0.3 mg. The test fails.

One continuous take, waits sped up and marked on screen. Asked for an HPLC part number the guide doesn’t give, Claude says so and won’t guess one.

Watch on YouTube
Animation · 48 seconds

How Alepou Spatial works

The headset is a universal client. A workflow is a folder of plain files, made by describing it to an AI. Swap the folder, and the headset stays the same.

Watch on YouTube Read it below
Built by asking · a puzzle

A real Rubik’s cube, solved in the headset

One spoken request, and the headset reads a real scrambled cube from six photos: an AI reads each face’s nine stickers, and you check each face or tap a sticker to fix it. A solver on the PC finds 22 moves, guided one at a time on a 3D cube. The headset app has no cube code, model or animations.

Edited for length from one continuous take.

Watch on YouTube
Built by asking · a game

Three games of Go against KataGo

One spoken request, and Claude opens a 9 × 9 Go board and a tea room an AI built. Three games against KataGo on the PC, playing like a 5 kyu human: game 1 resigned, game 2 lost by half a point, game 3 won by 13.5 after a 13-stone capture. The headset app knows nothing about Go.

Edited for length from one continuous take.

Watch on YouTube
Agentic spatial AI

Life-science data agents

Ask a question out loud in the headset, and an AI agent queries enterprise life-science data (drugs, deals, patents, chemical structures) and puts the answers in the room: a drug-pipeline chart, 3D molecules, a patent family.

Alepou’s first public spatial demo. One take in the headset, lightly edited for pace.

Watch on YouTube Demo page
Availability

Alepou is coming soon.

Built by Guy Entract. For early access, write to guy@varlis.io.

Contact guy@varlis.io

How it works

Swap the folder.
The headset stays the same.

The headset runs one client app that never changes. The AI, each app’s logic and the connections to real instruments run on your own computer. No instrument, cube or game is coded into the headset app.

Headset

Quest 3 · one Alepou client app
  • Draws models, panels, pieces and worlds
  • Voice in and out
  • Hands, gaze and a remote
  • Camera photos on request
Wi-Fi

Your computer

Alepou Desktop
  • The AI (Claude, also Codex), in sessions Alepou supervises
  • Writes each app as a folder of plain files
  • Runs each app’s logic: rules, scoring, steps
  • Perception: camera photos, object detection
  • Real instruments, such as a balance over serial
  • Blender and Unity, driven by the AI, for 3D assets
  • Speech, recording, audit trail
From anywhere
rubiks-cube-solver/
  • application.json
  • assets/reference-cube.glb
  • controls/reference-cube.json
  • lib/rubiks-service-core.mjs
  • lib/solver-adapter.mjs
  • lib/vendor/cubejs-1.3.2/index.js
  • data/solver-provenance.json
One app on the PC: the Rubik’s cube solver, as plain files.
  1. 01
    Ask

    Describe the app you want. AI agents build it on your PC as a folder of plain files, in sessions Alepou supervises.

  2. 02
    Run

    The PC runs the app’s logic, perception, instruments and speech. The headset draws what the app sends: models, panels, pieces and worlds.

  3. 03
    Swap

    Swap the folder and the same headset app runs a different app. Nothing about any of them is built into the headset app.

“So the person who knows the instrument builds the tool. No coding. No AI expertise.”

The closing line of the balance film
What runs underneath · Local control plane · BYO CLI

Your project folder becomes the AI control plane.

Underneath is Alepou’s workspace for long-running AI work, where every change is a task tied to a git commit, so the AI’s work stays inspectable.

Alepou wraps Claude Code, Codex CLI, and Google Antigravity CLI (Agy) — 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

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

Intelligence changes. Control shouldn’t.

Separate the intelligence from the governance.

Every model you use today will be replaced. The workflow around it — who approved what, which sources were authorised, what changed and when — has to outlive all of them.

Alepou adds that layer around the tools you already use instead of replacing them. Your editor, your official CLIs, your subscriptions, and your repository stay exactly as they are. What Alepou adds is the part that has to persist.

You choose the intelligence

Claude Code, Codex CLI, Agy, or any local CLI you add — commercial, open-weight, self-hosted, or regionally hosted. Alepou brokers no credentials and forwards no project context to a service of its own.

The governance stays put

Plans, memory, task state, and audit history are plain files and git commits in your repository. Changing models changes nothing about the record.

The mandatory stays deterministic

Probabilistic assistance sits on top. The steps that must happen do happen — as explicit tasks that end in an inspectable commit, in your real working tree.

Nothing is a black box

The prompts and session-init behaviour are surfaced in the interface for you to read and change. Adjust how the system briefs a model without touching code.

Additive by design — nothing here asks you to move your work somewhere new.

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

Agy 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 Agy
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
ClaudeCodexAgySupervisor
Ask one question to the room. Claude, Codex, and Agy 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 Agy ▶ 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 agy codex cli
$ claude
reading auth/token.js
patching refresh handler and retry flow now.
fix token refresh [in progress]

Claude, Codex, Agy — 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
ClaudeCodexAgy
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 Agy 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, and Google Antigravity CLI (Agy) 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.

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 Agy 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 bridges into real tools.

Use Alepou on its own, add Canvas when the work needs a visual stage, or bind a project to Unity and Blender when the important state lives inside those editors. 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.

Watch a supervised run
Optional companion · pre-release

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
Blender extension · alpha

Blender Bridge

Research real references, author native Blender scenes, inspect exact geometry and rendered evidence, repair defects, and retain accepted source assets for later assembly.

Explore Blender 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.

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.

Availability Coming soon · guy@varlis.io
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