The self-hosted control room for AI agents.
Build an agent, point it at a folder on your disk, and watch it work — with a live terminal, file tree, git diff, and dev-server preview beside every conversation. Your machine, your keys, your models.
Install · How it works · Security · Design record
A workspace, not a chat box. Every agent is rooted in a real directory on your disk. Open a thread against it and the same window gives you a live PTY (job control, full-screen apps; POSIX only), the file browser, the working-tree diff for every repo underneath, and any dev server the agent started — auto-detected, URL surfaced.
Agents you actually build. Full CRUD over agents, skills, subagents, and tools — per-agent model, instructions, and feature flags (todo, subagents, skills, memory, web search, thinking level).
Work that finishes without you. Plan → refine → execute, plus goal mode: a self-continuing loop that drafts a plan, optionally waits for approval, then works turn after turn until an independent evaluator judges the objective met.
Standing orders. Put an agent on a cron expression in its own timezone, so 9am survives DST. Each fire opens a fresh conversation as a single turn or a full goal run. Anything due while Lursor was closed is reported, never silently replayed.
Runs that outlive the context window. Long conversations summarize their own history before the window fills. Every agent and subagent can tune how full the window gets first, and how much history is summarized versus kept verbatim.
Streaming that shows the work. Assistant tokens and tool calls stream live over
AG-UI SSE. Threads self-name via a fast model; /compact folds up long ones.
Your bill, itemized. Token-usage and cost rollups per model, per workspace, per day.
Any model. OpenRouter out of the box; add custom providers, or drive local models — pull, serve, VRAM — through a laios daemon.
A backend that doesn't need your laptop open. Point the desktop app at a Lursor
backend on a VPS or a machine that stays on, over https with a token, and it becomes
a thin client: runs, goal loops and schedules keep going while your laptop is shut,
and you reconnect to whatever they got to. Even dev-server previews work — the app
forwards the remote port so localhost:5173 is the app it started.
docs/REMOTE.md.
Also in the box: file upload, GitHub integration on the changes panel, and a seeded library of prompt templates.
- Editor agents (Cursor, Cline, Claude Code) live inside one repo and one editor session. Lursor runs beside them: many agents, many workspaces, standing schedules, and a UI that persists after you close the terminal.
- Hosted agent platforms hold your keys, your source, and your history. Lursor is a local binary talking to a local SQLite file. Nothing leaves your machine except the model calls you configured.
- Chat UIs give you a message box. Lursor gives the agent a shell, a filesystem, and a git working tree — and shows you all three while it works.
The desktop app bundles its own backend — a frozen, self-contained Python
interpreter that Lursor starts and stops for you. No Python, uv, bun, or
manual server required.
curl -fsSL https://raw.githubusercontent.com/Systemized-Labs/lursor/main/scripts/install.sh | shThis downloads the prebuilt app for your OS/arch from GitHub Releases, verifies
it against the published SHA-256, and installs it — Lursor.app into
/Applications on macOS, or Lursor.AppImage into ~/.local/bin plus an
app-menu entry on Linux. Re-running it upgrades in place.
Builds aren't code-signed yet, so the installer clears the macOS quarantine flag
for you. That's also why this script — not Homebrew — is the macOS install path:
Homebrew dropped --no-quarantine in 4.7, so a cask can't do the same. A tap
lands once releases are signed and notarized.
To update an existing install — checks your version against the latest release and does nothing if you're current:
curl -fsSL https://raw.githubusercontent.com/Systemized-Labs/lursor/main/scripts/update.sh | shPin a version with LURSOR_VERSION=1.2.3, change the Linux install dir with
LURSOR_PREFIX, and remove it again with:
curl -fsSL https://raw.githubusercontent.com/Systemized-Labs/lursor/main/scripts/install.sh | sh -s -- --uninstallTo run the backend somewhere else — a VPS, or a box in the corner — so agents keep working while your laptop is shut, install the server half there instead. It builds from source and hands the backend to systemd (or launchd), so it survives a reboot, and prints the token the desktop app authenticates with:
curl -fsSL https://raw.githubusercontent.com/Systemized-Labs/lursor/main/scripts/install-server.sh | shThen add the connection in the app under Switch Connection…. Re-run the same command to upgrade. docs/REMOTE.md covers TLS, previews of remote dev servers, and what supervision does and doesn't protect you from.
Requires macOS on Apple Silicon or Linux x86_64; Windows and Intel macOS aren't built yet — run from source there. On first launch, paste an OpenRouter key or point at a local OpenAI-compatible endpoint. docs/INSTALL.md covers the walkthrough, where your data lives, and how updates work.
One command, both processes:
./scripts/dev.sh # backend + frontend in the browser
./scripts/dev.sh --electron # ... in the Electron desktop shell
./scripts/dev.sh --electron --debug # ... and auto-open Chrome DevToolsCtrl-C stops both. Or run them separately:
# backend
cd backend
uv sync --extra dev
cp .env.example .env # add your OPENROUTER_API_KEY
uv run uvicorn app.main:app --reload --port 8791
# frontend
cd frontend
bun install
cp .env.example .env # VITE_API_BASE defaults to http://localhost:8791/api
bun run devThen open the Vite URL (default http://localhost:8888).
docs/ELECTRON.md covers how the desktop app is wired and how to
package a distributable.
| Layer | What it is |
|---|---|
| Agent engine | pydantic-deepagents — planning, filesystem, subagents, skills, memory, on Pydantic AI |
| Backend | FastAPI + SQLite |
| Frontend | Vite + React + Tailwind + shadcn/ui, also shipped as an Electron app |
| Streaming | AG-UI over SSE, via Pydantic AI's first-party adapter |
| Models | OpenRouter, custom providers, or local models via laios |
lursor/
backend/ FastAPI + pydantic-deepagents + SQLite (see backend/README.md)
frontend/ Vite + React + Tailwind + shadcn/ui (see frontend/README.md)
also runs as an Electron desktop app (see docs/ELECTRON.md)
docs/ Desktop and release docs
design record lives in AGENTS.md at the repo root
scripts/ dev.sh — run backend + frontend together
Lursor is single-user, and the backend is as privileged as a shell on your machine. It hands agents a real PTY and unsandboxed command execution, stores provider API keys unencrypted in SQLite, and accepts requests from any origin.
By default it runs unauthenticated on loopback — keep it there. The desktop app
already does; scripts/dev.sh binds 0.0.0.0 for LAN convenience. Never expose an
unauthenticated port to the internet or an untrusted network.
To run it on another machine, set LURSOR_AUTH_TOKEN and put TLS in front of it.
Every route then requires that token — treat it as an SSH key for that host, because
that is what it is worth. docs/REMOTE.md is the runbook.
SECURITY.md has the full threat model, safe-operation notes, and how to report a vulnerability privately.
MVP, actively growing. AGENTS.md is the design record — the architecture, the subsystem-by-subsystem decisions, the invariants worth knowing before you change anything, and what is deliberately not built. Auth, multi-tenancy, and Docker sandboxing remain intentionally deferred.
Issues and PRs welcome. If you're changing behaviour, read AGENTS.md first — it will tell you whether the thing you're about to "fix" is load-bearing.