Build the AI software your team needs. Run it on Lemma.
Quickstart · Why a harness · Inside a pod · Surfaces · Coding agents · Docs
Website → lemma.work
The exact software a team needs usually does not exist. Coding agents can now create it.
But generated code is not yet working team software—it still needs shared state, permissions, workflows, approvals, deployment, and somewhere agents can keep working.
Lemma supplies that missing system. People use the app; agents work through the same state and workflows.
Open source. Run it on your laptop, your server, or Lemma Cloud. Use Claude Code or Codex through your existing subscription, Lemma-managed models, or any OpenAI- or Anthropic-compatible provider.
Download Lemma Desktop, choose Local, and select Install local services. Lemma owns the local runtime, and the CLI discovers it automatically.
Desktop installation and local runtime details
Download the signed online package from the latest release for macOS 14+ on Apple silicon or Windows 11 23H2+ on x86-64. On macOS, drag Lemma to Applications before opening it; on Windows, run the signed setup executable. The small installer downloads digest-verified runtime components on first use; public offline packages are not offered in this release.
Choose Local, select Install local services, and create the local owner inside the app. Lemma owns its lightweight VZ/WSL2 runtime; the normal path does not install or require Docker Desktop, Podman, Homebrew, Python, Node.js, Ubuntu, or public DNS. Configure the required AI profile and optional integrations in Local Control Center.
On first installation Lemma chooses a private high-port pair and keeps it stable across restarts. Local Control Center → Diagnostics shows the exact workspace, API, built-app, and OAuth callback URLs. The CLI discovers the same endpoints from Desktop automatically. See the complete local installation and operations guide.
Install the CLI, connect it to the local stack, and give your coding agent Lemma's skills:
uv tool install lemma-terminal
# The optional stack-control bootstrap registers the `local` server:
curl -fsSL https://raw.githubusercontent.com/lemma-work/lemma-platform/main/install.sh |
bash -s -- --cli-only
lemma servers select local
lemma auth login
lemma skills install
lemma pod create my-team --with-starterOpen the generated my-team/ directory in Claude Code, Codex, OpenCode, Cursor, or Antigravity and ask it to build the app you want. Antigravity users should first run lemma skills install --target agents --scope project from inside that directory. The coding agent authors and verifies the pod through the same CLI.
To let the pod dispatch runs through your local Claude Code, Codex, OpenCode, or Cursor login, pair this machine as an Agent Host and point a runtime profile at one of its harnesses.
In Lemma Desktop, open Models and press Connect this computer, then Add to chat models on the agents it finds. Headless, the same thing from the CLI:
lemma agent-host connect # pairs using your existing CLI login
lemma agent-host harnesses # lists harness_id per detected tool
lemma runtime profiles create AGENT_HOST \
--name "Codex on my laptop" --harness-id <harness_id>Then select that profile on an agent (lemma agent update <name> --data '{"agent_runtime": {"profile_id": "<profile_id>"}}') and chat as usual.
lemma agent-host status shows the paired targets and whether the host service
is running.
Agent Host drives each tool over the Agent Client Protocol.
Antigravity (agy) has no ACP mode yet, so it can install Lemma's skills and
author pods but cannot serve pod-dispatched runs.
Configure a provider for server-run agents and conversations
Use Local Control Center → AI Providers, or apply the same transactional
configuration through lemma-stack:
lemma-stack config set ai.protocol=openai_compat ai.base_url=http://127.0.0.1:11434/v1 ai.default_model=qwen3Secrets are stored in Keychain or Credential Manager, model access is validated before activation, and a failed change rolls back. See configuration for hosted providers, integrations, and agent surfaces.
Sign up at lemma.work when you want the same stack hosted and reachable by teammates and surfaces:
uv tool install lemma-terminal
lemma servers select lemma-cloud
lemma auth login
lemma skills install
lemma pod create my-team --with-starter # scaffolds a working starter (table + agent) and imports it
lemma chat "what can you do in this pod?"The shape of a Lemma harness follows the job. The app is how people use it:
Personal expenses. Send a receipt or voice note through Telegram. An agent extracts the purchase, asks when something is unclear, and keeps the ledger current. The app is where you review transactions, correct categories, and see where the money went.
Research. Agents gather sources, extract claims, and challenge weak evidence in the background. The app holds the sources, claims, open questions, and evolving brief. You inspect the work, redirect the investigation, and shape the result.
Customer support. Agents read new requests, gather the relevant context, draft replies, and flag decisions. The app brings together the conversation, proposed response, customer history, and the controls to edit, approve, or direct what happens next.
Each harness gives its job a purpose-built interface, shared state, and agents that keep working between visits. People work with what the agents produce and direct what happens next; the agents carry that direction back into the work.
Completed work leaves reusable structure behind. A triaged email becomes a record. You save repeated corrections as standing instructions, promote repeated sequences to workflows, and encode recurring judgment in agent roles — with approval gates wherever people stay responsible.
A pod exports as portable files: tables, agents, workflows, permissions, apps, and the rest of the system. The same coding agent that built it can export, change, verify, and re-import it. Remix it, share it, or start from one somebody else built:
lemma pod export ./support-desk # the whole system, as files
lemma pod import ./support-desk # ship it back — or to another machineEverything in Lemma lives in a pod — a self-contained environment for one person, team, or process. A pod holds shared state, agents, workflows, permissions, and one or more apps.
| Primitive | What it gives you |
|---|---|
| Tables | Typed, queryable business data with row-level security. Leads, tickets, tasks, approvals — readable by agents, owned by the pod. |
| Files | Markdown memory for preferences, playbooks, voice guides, and notes. Full-text searchable, permission-scoped, read and written by agents alongside the tables. |
| Agents | LLM workers with a role, tool grants, and access scoped to specific tables, files, and connectors. |
| Workflows | Graphs that mix agents, functions, decisions, loops, waits, and human approval steps. Triggered by schedules, webhooks, table events, chat, or the API. |
| Functions | Predictable validators, transitions, and actions alongside agent judgment. |
| Permissions | Roles for people and agents: pod-level roles, table grants, resource visibility, delegation tokens. |
| Approvals | Workflow steps that pause, route to a specific person, and resume on their decision — in the app or in Slack. |
| Apps | The UI where people see the job, direct work, and handle decisions — deployed at a URL and built on the same pod APIs as the agents. |
| Surfaces | Slack, Microsoft Teams, Gmail, Outlook, Telegram, and WhatsApp — wired to pod agents with identity resolution and conversation linking. |
A teammate approves a refund in Slack. A field update arrives as a WhatsApp voice note and lands as a structured record. An agent drafts a customer reply in Gmail and waits for a human before sending. The conversation is the surface — underneath, all of it reads and writes the same tables, runs through the same workflows, and respects the same permissions.
Supported today: Slack, Microsoft Teams, Gmail, Outlook, Telegram, WhatsApp — each with webhook ingress, identity resolution, and agent-initiated actions. Telegram long-polling and Slack Socket Mode connect local setups directly.
| Surfaces |  Slack |
 Teams |
 Gmail |
 Outlook |
 Telegram |
 |
Wherever your team already works, the pod shows up.
A pod also works for one person. One human and a few agents — with WhatsApp as the front door and tables as the memory — make a personal assistant that keeps state, asks before it acts, and picks up tomorrow where it left off today.
A pod can be exported as plain files, so building one is a job a coding agent is already good at: describe the system, let the agent author the bundle, and import it. The agent that builds it also tests it by creating records, running workflows, and chatting with the agents it defined. Building and operating use the same CLI.
 Claude Code |
 Codex |
 OpenCode |
 Cursor |
 Antigravity |
The same agent authors the app, data, agents, workflows, and permissions—then verifies the result.
Install Lemma's skills into the agent you already use — Claude Code, Codex, OpenCode, Cursor, or Antigravity:
lemma skills install # auto-detects Claude Code / Codex / OpenCode / Cursor
lemma skills install --target claude --all-skills # or pick a target and include runtime helpers
lemma skills install --target agents --scope project # Antigravity, from inside the pod directorySkills ship in lemma-skills/. Restart your coding agent after installing, then ask it to build a pod:
lemma pod init my-team # scaffold a starter bundle to edit (or: lemma agent|table|workflow init …)
lemma pod import ./the-pod-your-agent-wrote
lemma apps deploy my-app ./index.html # deploy a no-build HTML app (or a Vite project dir)Or run your agent inside Lemma. Agent Host connects your local Claude Code, Codex, OpenCode, or Cursor to the pod: it picks up tasks from a durable queue, streams its work back through the pod, and pauses at approval gates before protected actions. Two agents working the same pod share persistent state, a task queue, and run history.
lemma auth login
lemma agent-host connect # pair this machine (one command, no code to copy)
lemma agent-host harnesses # harness_id for each detected coding agent
lemma runtime profiles create AGENT_HOST \
--name "Codex on my laptop" --harness-id <harness_id>
lemma agent-host status # paired targets, service state, queue depthPairing from the CLI installs Agent Host as a per-user background service, so
it survives logout and reboot. Lemma Desktop supervises it instead and runs it
while the app is open, so lemma agent-host start|stop|restart route through
Desktop rather than installing a second service. See
Agent Host in the desktop app.
Any agent operates a pod directly through the CLI:
lemma table list # inspect the data model
lemma record update tasks rec_8f2k --data '{"status": "done"}'
lemma agent run qualifier --input '{"lead_id": "..."}'
lemma workflow start follow-up # pauses at human approval steps
lemma chat "what's left in the queue?"If you're reading this inside a coding agent session: that agent can work a pod right now.
Python and TypeScript SDKs (with 25+ React hooks) live in lemma-python/ and lemma-typescript/. Generating your frontend elsewhere? Back it with a pod — the TypeScript SDK gives any app tables, agents, workflows, and permissions out of the box.
- Your machine. The full stack runs self-contained on your laptop. You choose which external services receive data.
- Our cloud, when you want it. lemma.work runs the same open-source stack as a hosted option for pods that need to reach teammates and surfaces.
- Your subscription, managed models, or your keys. Pod-assigned runs use your local Claude Code or Codex login through Agent Host. Server-run agents use Lemma-managed models or an Anthropic-compatible or OpenAI-compatible key or endpoint — a cloud provider, a self-hosted gateway, or a local model. Runtime profiles are per pod, so different agents can use different models.
- Your code. Core is AGPLv3; SDKs, CLI, and tools are Apache-2.0.
| Path | Package | License |
|---|---|---|
lemma-backend/ |
FastAPI backend, migrations, and infra Docker Compose | AGPLv3 |
lemma-frontend/ |
Next.js frontend | AGPLv3 |
agentbox/ |
Sandboxed agent workspace manager and runtime image | Apache-2.0 |
agentbox-client/ |
Python client for the AgentBox workspace API | Apache-2.0 |
lemma-stack/ |
lemma-stack — installer and manager for a self-contained local stack |
Apache-2.0 |
desktop/ |
Tauri macOS desktop app (thin shell around the lemma-stack supervisor) |
AGPLv3 |
lemma-cli/ |
lemma-terminal — the lemma CLI and terminal UI |
Apache-2.0 |
lemma-python/ |
lemma-sdk — Python SDK |
Apache-2.0 |
lemma-typescript/ |
lemma-sdk — TypeScript/JavaScript SDK for Node, browser, and React |
Apache-2.0 |
lemma-skills/ |
Built-in agent skills | Apache-2.0 |
docs/ |
Installation and setup guides | — |
install.sh |
One-line bootstrap installer | — |
Everything is a normal directory in one repo.
For contributing to the platform itself — hot-reload from source:
git clone https://github.com/lemma-work/lemma-platform.git
cd lemma-platform
make init # install dependencies and create persistent local configuration
make dev # run backend, frontend, and AgentBox with local debug/request logs
make dev-public # add an ephemeral public API URL for webhooks and surfaces
make logs # tail infrastructure container logs
make stop # stop dev app, AgentBox, and tunnel processes
make stop-all # also stop dev infrastructureRun make help for the full list. The dev stack uses explicit development
ports (frontend 3710, backend 8710). Managed Desktop installations choose
persistent high ports instead.
make dev-public requires cloudflared and creates one temporary
*.trycloudflare.com URL for the API. The frontend and auth UI stay on
http://localhost:3710, while the public API URL is injected into the frontend,
webhook callbacks, and generated API links for that run. The quick-tunnel URL
changes on every restart and is intended only for development.
Backend-only commands live in lemma-backend/:
cd lemma-backend
make test
make lint
make migrateSee docs/installation.md for the full setup guide,
lemma-backend/README.md for backend details, and
lemma-frontend/README.md for frontend details.
The Lemma platform uses a dual-licensing model:
AGPLv3 (server-delivered core):
lemma-backend/— the FastAPI backendlemma-frontend/— the Next.js frontend and operator UI
These are licensed under the GNU Affero General Public License v3. If you modify and offer the software over a network (e.g. a hosted SaaS), you must release your modified source under the same terms.
Apache-2.0 (client-side developer tools):
agentbox/— sandboxed agent workspace manager and runtime imageagentbox-client/— Python client for the AgentBox workspace APIlemma-stack/— local stack installer and managerlemma-cli/— thelemmaCLI and terminal UIlemma-python/— the Python SDKlemma-typescript/— the TypeScript SDKlemma-skills/— agent skills
These are intended for broad embedding, installation, and adaptation, so they
remain Apache-2.0 and include their own LICENSE files.
Commercial licensing and exceptions are available from Folks and Machines, Inc. for organizations whose procurement policies do not accommodate AGPLv3. The commercial exception neutralizes the AGPL procurement friction while keeping the core genuinely open source.
Trademark: The Lemma name, logos, and marks are trademarks of Folks and Machines, Inc. and are not granted by the software licenses. Fork the code, not the brand.
Lemma is built by Folks and Machines, Inc., a Delaware corporation. © 2026 Folks and Machines, Inc.