Now inviting Beta testers · Public waitlist open

The control plane for AI software development.

Turn multi-step plans into durable tickets, then route them through build and review across agent runs. Configured workers keep moving when you step away, while queues, sessions, blockers, and runtimes stay visible in one place.

Join the Beta waitlist See what you'll need

Already invited? Open Beta on GitHub →

Runs on your stack:Docker executionAnthropic-compatibleLM StudioOllamaClaude CodeMore tools coming

The problem

Agent runs end. Your plan shouldn't.

Planning the work up front should remove coordination overhead. It should not leave you relaunching sessions, rewriting handoff prompts, and tracking parallel work by hand.

Sessions end. Plans shouldn't.

Agent runs time out or hit context limits. Durable tickets and queue state keep the next step intact.

Babysitting wastes the plan

Without orchestration, every finished run means another review, continuation prompt, and manual restart.

Self-review is not review

Writing and reviewing need separate roles, captured evidence, and a guarded merge.

One model doesn't fit every task

Local and cloud-backed workers offer different cost, privacy, speed, and reasoning tradeoffs.

Parallel work is hard to track

Multiple projects and agent runs need one place to show what is queued, running, blocked, or done.

Failures shouldn't erase progress

Supported failures should retry or create bounded recovery work; unsafe cases should stop with a clear reason.

One control plane

Give the plan a durable operating layer.

LStack keeps intent and workflow outside any one agent run. Work can be planned, routed, reviewed, recovered, and run from one persistent control surface.

Plans, tickets & queue — durable state that outlives an individual agent run.
Managed workers & providers — local or cloud-backed capacity routed by policy and assignment.
Review & project runtimes — check work through a separate role, then start and inspect what gets built.

Control planedashboard

Projects · tickets · queue · workers · providers · runtimes

↓

Worker runtime planecontainers

Long-lived workers running your chosen execution tool — Claude Code today, with more planned

↓

Project runtime planelocalhost

Per-project containers running the software each project produces

How it works

From a durable plan to reviewed, running software.

Connect a compatible model

Add an Anthropic-compatible provider and create Claude Code workers today. Codex and more execution tools are coming.

Plan durable work on the board

Break multi-step work into prioritized tickets. Statuses become execution signals, and queue state persists across agent runs.

Watch it build, review & run

In automated review mode, a separate reviewer-role worker checks the result before guarded merge. Then run it at localhost.

Capabilities

Operate work beyond a single agent run.

Working today with a native local control plane and Docker-powered execution. Tagged honestly.

Durable ticket workflow NOW

Plan multi-step work as persistent tickets. Status, dependencies, priority, and queue state survive individual agent runs.

Managed AI workers NOW

The scheduler keeps assigning eligible queued work to non-interactive workers while capacity is available, and surfaces blockers when help is required.

Model choice by worker NOW

Create Claude Code workers from compatible local or hosted providers today, then route tickets through worker policy or explicit assignment.

Independent review role NOW

Automated review mode routes completed work to a separate reviewer-role worker before guarded merge. Builder and reviewer may use different models.

Isolated workspaces NOW

Every project is a real folder; every session pinned to one path. On-disk docs and per-ticket git worktrees.

Managed runtimes NOW · NEWER

Run what you build — CLI, service, site, or stack — from the dashboard. Logs, run history, localhost URLs.

Bounded recovery NOW

Supported failure classes retry or create recovery work through the normal review path. Unsafe or exhausted cases stop with a visible reason.

Local-first control NOW

Code, data, infrastructure, and models stay with you. Loopback-only exposure; encrypted per-project secrets.

Local-first & yours

Your machine. Your models. Your board.

The code, the project data, the infrastructure, and the model endpoints stay under your control. LStack runs against local or compatible model servers — not locked to a single hosted platform.

Ownership

Project context lives as real files on disk that move with the project.

Isolation

Each assignment gets an isolated execution worktree; a worker is pinned to one active project path at a time.

Model flexibility

Bring compatible endpoints; set concurrency caps that fit your hardware.

your machine

models

local · compatible

workers

isolated

projects

on disk

runtimes

127.0.0.1

↑ nothing leaves without you

Early, on purpose

Now inviting Beta testers. Public release is next.

Today LStack runs a native control plane on your machine, with Docker handling workers and project runtimes. It already runs real work — projects, durable queues, builder/reviewer flow, bounded recovery, and the software those projects produce.

You are here · Beta

Private Beta

We invite selected testers directly from the waitlist — no access codes. Approved testers are added to our private GitHub Beta repository for the release, issues, and discussion.

Next · Release

Public release

A polished, downloadable release. Join the waitlist to be first in line and help shape it.

Later · Direction

Desktop & headless

A desktop app and one-line server install — native core on the host, Docker for execution.

Get on the list

Join the public Beta waitlist.

Be first to know when LStack opens. No spam — just launch news and your Beta invite.

Double opt-in, unsubscribe anytime

Already invited? Open Beta on GitHub →