Features

A project holds a local path or a git URL, its AI settings, environment variables, ports, scripts and a generated Dockerfile and Compose file. The desktop builds and starts the container. A project created from the cloud board syncs to the desktop, which writes the Docker files, and the container can then be started from the browser. Creating one is a short wizard with tabs for Project Info, AI instructions, AI Auth, AI Roles, Environment Variables, Ports, Scripts, Containers, Docker Compose and Dockerfiles.

The generated Dockerfile starts from Ubuntu 26.04 by default, with Ubuntu 24.04 and Debian 13 offered. A hand-edited Dockerfile or Compose file is used as written. The app still applies its rules on top: ports bound to localhost unless marked LAN, the startup script, the gVisor runtime on Linux where it is installed, the memory cap and the project's own network.

Containers are built for the Docker daemon's architecture by default, arm64 on Apple silicon and x64 on a PC. A project may pin an architecture, which syncs. On the other kind of machine it runs emulated, slower and never under gVisor. Combinations that cannot work are refused before a build starts.

Automatic by default, derived from the host's total memory with a reserve kept for the host. A watcher reports a container that keeps dying and restarting, which Docker would otherwise hide.

Host and container port pairs per project, bound to localhost unless the LAN flag is set, because a Docker-published port bypasses the host firewall. The app warns when another project already claims the port, even a stopped one, and when something on this machine is already using it. Each row after the first is filled with the next number.

The startup script runs once at container start. Named scripts run inside the container with the same environment a task run gets, stream their output live to the board, and can be run, stopped and tested from the browser and the phone while the desktop is online. A running script keeps going when the app closes, and after a restart the board picks it up again with its stop button and its most recent output. Output is not stored, so the panel has a copy button.

Values are encrypted at rest with AES-256-GCM and injected at the moment the agent's shell starts, never into Docker files. Two flags per variable: write-only, so the value never leaves the server once set, and device-local, so it stays on this machine and does not sync. Task runs, the terminal, scripts and flows all see the same variables.

Account-level credentials linked into projects rather than copied into them. Linking works from a browser or a phone, because the link is a name and not the credential. No screen ever shows a value. The key is used only on the machine that runs the container. A deleted key leaves the link in place so the failure is loud, not silent.

Each project has its own Docker network, once a project created on an older version has been moved onto it. Connecting two projects creates a pair network between them. The setting syncs. Moving a running project onto its network recreates the container, so it happens on start, restart, rebuild or an explicit move from Settings.

An interactive terminal in persistent per-project tabs. From the cloud board and the phone the shell runs on your desktop and is relayed to you. Links in the output open with Ctrl or Cmd click. Sessions end on tab close, End all, shell exit or app close.

Lists one directory of the project container at a time. Never the host filesystem, which no networked client can browse by design. Says why it cannot list rather than showing an empty folder.

Restart and rebuild recreate the container, which discards uncommitted work in a container-only workspace, and the same confirmation appears on every surface. A failed start is reduced to the one line that matters, such as a port conflict or a build error, and raises one notification that opens the tab holding the fix.

Every build removes the image it replaced unless something still uses it. Settings shows Docker disk usage and offers safe prunes only, dangling images and build cache. Deleting a project stops its containers. Destroying it from the recycle bin purges its containers, volumes, networks and images.

The repository is cloned into the container on first start. The credential and the commit identity ride the environment of every run, terminal, script and flow. When a run switched branch or committed, a manual step offers the pull request URL for GitHub, GitLab, Bitbucket or Gitea.

The sign-in is spent on one call that creates a per-repository deploy key with write access, then discarded. Nothing about the sign-in is stored. The result is an SSH key and SSH URL, the same as a hand-pasted setup. The link can be finished in any browser or on a phone. GitLab only. GitHub users paste a deploy key or a token instead.

With gVisor installed on Linux, project containers run with its runtime, a user-space kernel that intercepts system calls. On macOS and Windows, Docker Desktop's virtual machine provides the isolation and gVisor is not used. Each project is on its own network, once one created on an older version has been moved there.

Per-project opt-in. The agent reaches Docker only through a policy proxy that allows the sibling containers the agent created on the project's own network, holds them to the same localhost port rule, and refuses everything else. Before a run starts, the app checks that the container can reach the proxy, and pauses the queue with the firewall rule to add if it cannot. On Linux with ufw, that one rule is added under one administrator prompt.

Per project. Runs To Do tasks in position order, honouring declared prerequisites and skipping a task that overlaps work a blocked task left half-done. One run per project. When the queue pauses it says why, in a sentence, with a Resume button where a press can fix it: credits, a plan refusal, retries exhausted, a failed task, a firewall block. A rate limit resumes by itself, a cost budget resumes when its spend is reset or raised, and a prerequisite when that task is done. The reason shows in the browser and on the phone too.

Stop relays to the desktop and the stopped run is archived. A retry is told what the previous attempt did, so it does not assume that work landed. A second manual run while one is going is queued rather than started twice.

Output streams to every open board. The browser and the phone see the same output. The run's start time is stored, so a reloaded page or a second device shows the true elapsed time.

A record per run with outcome, model, output and cost. Older transcripts never reach a model. The review after a run is told only that earlier runs happened and how they ended. Transcript history on the cloud is part of the Pro and Max plans and the trial. The task dialog's copy and download buttons turn a task into one Markdown document with its description, its comments and its last run.

Off by default and enabled per project. The reviewer reads what the run changed and committed against what the task asked, in a separate call. A negative verdict is a comment. It never re-runs anything on its own.

A run that goes back to To Do carries a record of what it did, stated as started rather than succeeded. When a failure repeats, the app judges whether another attempt can help and blocks the task with the reason when it cannot.

A question pauses the task and holds the queue until you answer. A wait keeps the task's place while the app checks for the awaited result, then runs it again first in line. Manual steps arrive as an action comment with a flag and a notification. A run that ends without saying how it ended is recorded honestly rather than assumed done.

A run may propose new tasks, created in Planning under the original with a per-run and per-family cap, then promoted. Breakdown is flat: a family is a root plus siblings, and opening the root lists every related task.

A run reports what it installed, and the report is added to the project's Dockerfile with a notification offering the restart that applies it. Every runner also records the commands it actually ran. An install that went unreported is picked out, rewritten for image-build time and added to the Dockerfile as lines to try. The next restart or rebuild builds them, and a build that fails removes them again and tells you. When the commands cannot be rewritten, you get them in an action comment to add yourself.

Claude and OpenAI publish machine-readable status. Google's covers a broader service and is shown with that caveat. xAI publishes none. Read once per failure, never polled.

A flow is a small graph of steps. An analysis decides which steps can run as plain code, generated once and re-run for free, which need a model, and which only carry data. Generated code runs in the project container. No overlapping runs, a stale analysis blocks the run, per-step and per-run ceilings, disabled by default, and missed windows are never caught up. A run of failures warns you. A flow can also fire when a task reaches Done or Blocked.

The desktop serves the same board over HTTP to the local network. Login-free by design, so keep it to networks you trust. Off by default.

Projects, tasks, comments, chat, notes, notifications and, on Pro, Max and the trial, attachments sync between the desktop and the cloud. Two devices editing the same task keep both edits. A deleted item is not brought back by a later edit made elsewhere. A task never disappears because two devices disagree. On reconnect only the difference is transferred.

The same board at board.boragosoft.com in your phone's browser, laid out for a phone, with a rail for moving cards across columns and the project controls as labelled rows. Answer questions, create tasks, start containers and open a terminal while your desktop is online.

The desktop shows a short code you approve in a signed-in browser or phone session, inheriting your password manager and 2FA. Each account links one desktop installation. Switching accounts on one machine keeps each account's database and project folders apart.

A business with two membership kinds, DNS-verified domains, and split-key shared credentials sealed so that the server alone cannot decrypt them.

The app resolves the Docker command itself, reports whether the daemon is running, stopped or unreachable, and offers the fix for each in the app. On Linux one script installs the distribution's own Docker packages, adds you to the docker group, installs and verifies gVisor and grants access to the socket so no restart or log-out is needed. On Mac and Windows it downloads the official installer, checks it against Docker's published checksum and opens it.

The AppImage replaces itself and repoints your menu entry at once. The Mac app downloads an update in the background and installs it when you restart, when it runs from your Applications folder. Opened from the disk image or straight from Downloads, it tells you when a release is out instead. Every installer URL is unique per version.

The app detects whether your desktop has a tray, so Ubuntu, Fedora, KDE and the rest each get the right behaviour. The setting is named for its effect: keep running when the window is closed.

No identifiers. Secrets scrubbed on your machine and again on receipt. Sent only when you press the button. Logs are kept per account so one account's report cannot carry another's work.

The config directory, the projects directory and the containers are all left in place by an uninstall, on purpose. The guide names each path per platform.