Show HN：Lemma.work——可供整个团队共享的开源 AI 同事

---

一个多人协作、可自我改进的运行框架

运行框架（harness）是模型周围的一切：它能够调用的工具、读取的记忆、写入的状态、所运行的循环，以及其工作边界。编码 Agent 为一个人、在一台机器上、持续一个会话的时间提供了一个运行框架。

Lemma 则是面向团队的这一运行框架。状态可共享且受权限控制，因此许多人和许多 Agent 可以操作同一批记录。它会在会话之间持续运行，也可由定时任务、webhook 和表格事件触发。它还能不断积累：修正会成为长期指令，操作序列会成为工作流，判断会成为 Agent 角色。你的团队下个月使用的运行框架会比今天交付的版本更好，因为使用它本身就是改进它的过程。

你的编码 Agent 会构建它。向 Claude Code、Codex、Cursor、OpenCode 或 Antigravity 描述任务；它会将整套系统写成文件，包括用户打开的应用、底层表格、Agent、工作流和权限。随后，它通过同一套 CLI 导入并验证结果。你的团队可通过一个 URL 打开它，或从 Slack、Teams、Telegram、WhatsApp 或电子邮件访问它。

开源。可在你的笔记本电脑、服务器或 Lemma Cloud 上运行。可通过现有订阅使用 Claude Code 或 Codex，也可使用 Lemma 托管模型，或任何兼容 OpenAI 或 Anthropic 的提供商。

同一套技术栈，可托管，并可供队友和各类入口访问：

uv tool install lemma-terminal
lemma servers select lemma-cloud
lemma auth login
lemma skills install
lemma pod create support-ops --with-starter   # scaffolds a working starter (table + agent) and imports it
lemma chat "what can you do in this pod?"

下载 Lemma Desktop，选择 Local，然后选择 Install local services。Lemma 负责本地运行时并自行选择端口，因此一条引导命令会从 Desktop 读取这些端口，并将它们注册到 CLI 中，作为 local 服务器。

在 Desktop 的本地设置首次完成后，运行以下命令：

uv tool install lemma-terminal
curl -fsSL https://raw.githubusercontent.com/lemma-work/lemma-platform/main/install.sh |
  bash -s -- --cli-only          # registers Desktop's endpoints as the local server
lemma servers select local
lemma auth login
lemma skills install
lemma pod create support-ops --with-starter

然后在你已使用的编码 Agent 中打开生成的 support-ops/ 目录，并描述你希望构建的系统。完整的 Desktop、Agent Host 和模型提供商设置说明见 Install in depth 和 docs/installation.md。

请使用 uv tool install，而不是 pip。lemma-terminal 需要 Python 3.14，而 uv tool install 会自行配置该解释器，因此你的机器上 python3 的版本无关紧要。在较旧解释器上运行 pip install lemma-terminal 不会报错——它会悄悄解析回允许 Python 3.11 的最后一个版本 0.6.2，并安装一个比服务器落后多个小版本的 CLI。lemma --version 会报告你实际安装的版本。

如果某条命令没有按这里所说的方式运行：

症状	处理方式
Server not found: local	Desktop 的本地设置尚未运行，或跳过了上述引导步骤。请运行它，然后执行 lemma servers show 确认当前激活的是哪台服务器。
Agent 不可用，或聊天回答模型提供商错误	尚未验证任何 AI 提供商。进入 Local Control Center → AI Providers；如果你没有 API key，可使用 Ollama 或 LM Studio。
某项功能在应用中可用但在 CLI 中不可用，或反过来	使用 lemma doctor——它会诊断客户端/服务器版本不匹配和重复安装问题。

无论多少人，共用同一个它

你共享的是已经在运行的同一个 Agent。把链接发给某人；对方会打开同一个 Agent，其工作会落入相同的记录中。需要修复的是同一个它，需要改进的是同一个它，底层也是同一组记录。

按每个人的范围划分：

人员	角色	访问权限
Priya	所有者	批准任意金额的退款
Marco	成员	处理自己的任务；退款请求转交 Priya
Classifier	Agent	读取工单；只读

同一套系统，不同的权限。同一个版本，面向所有人。

构建、发布，并交付给你的团队

01 · 在你已经使用的地方构建。 Claude Code、Codex、Cursor、OpenCode，或直接在 Lemma 内部。Agent 编写表格、Agent、工作流、权限和应用，然后通过同一 CLI 验证它们。

02 · 应用及其 Agent 一同上线。 为使用它的人提供一个 URL。Agent 根据定时任务、webhook 和表格事件工作，并在所有人登出后继续运行。

03 · 邀请你的团队，以及其他有需要的人。 队友、客户和访客都会获得邀请链接、应用，以及 pod 内属于自己的账户。

04 · 精确决定每个对象可以触及什么。 一套权限模型覆盖人员与 Agent：逐表授权、资源可见性，以及对关键步骤设置审批关卡。

05 · 从你已经在使用的任何地方访问。 Slack、Telegram、WhatsApp 和电子邮件，或直接作为应用打开。每个入口都在相同权限下读取和写入同一批记录。

Lemma 中的一切都存在于一个 pod 中：这是一个为个人、团队或流程准备的自包含环境。一个 pod 保存共享状态、Agent、工作流、权限，以及一个或多个应用。

原语	为你提供的能力
表格	具有类型、可查询且支持行级安全性的业务数据。线索、工单、任务、审批：Agent 可读取，且归 pod 所有。
文件	用于偏好、操作手册、语气指南和笔记的 Markdown 记忆。支持全文搜索、权限范围控制，Agent 可与表格一起读取和写入。这是策略所在之处：可版本化、可编辑，并在运行时读取。
Agent	配备角色、工具授权和访问范围的 LLM 工作单元，其权限限定到特定表格、文件和连接器。
工作流	混合 Agent、函数、决策、循环、等待和人工审批步骤的图。可由定时任务、webhook、表格事件、聊天或 API 触发。
函数	可预测的一半：相同输入，每次都会产生相同输出。用于验证器、状态转换和外部动作的普通代码。Agent 将其作为工具调用，因此判断与规则可以保持分离。
权限	面向人员 和 Agent 的角色：pod 级角色、表格授权、资源可见性、委托令牌。
审批	可暂停的工作流步骤：将任务路由给特定人员，并在其作出决定后于应用或 Slack 中恢复。即使审批要几天后才完成也可以。
连接器	每一个连接都会展示其账户、访问权限和使用方，因此“Agent 可以向客户发送邮件”是一项你看得见的设置。
应用	人们查看任务、指挥工作和处理决策的 UI。部署于一个 URL，并构建在与 Agent 相同的 pod API 之上。Agent 写入后，应用会立即展示结果。
入口	Slack、Microsoft Teams、Telegram、WhatsApp 和电子邮件，可通过身份解析和会话关联连接至 pod Agent。

运行框架会自我改进

完成的工作会留下可复用的结构。完成分流的电子邮件会成为一条记录。重复出现的修正会成为长期指令，重复的操作序列会成为工作流，反复出现的判断会成为 Agent 角色；而在人员仍需承担责任的环节，则设置审批关卡。

无论工作以何种方式到来，都会进入同一个 pod

一名队友在 Slack 中批准退款。一项字段更新以 WhatsApp 语音笔记的形式到达，并落为结构化记录。Agent 通过电子邮件起草客户回复，并在发送前等待人工确认。对话只是入口；在其底层，所有内容都会读取和写入相同的表格、运行相同的工作流，并遵守相同的权限。

目前支持：Slack、Microsoft Teams、Telegram、WhatsApp 和电子邮件。每种入口都具备 webhook 接入、身份解析和 Agent 发起动作的能力。Telegram 长轮询和 Slack Socket Mode 可将本地部署直接连接起来。

每个 pod Agent 都拥有自己的地址，任何人都可以通过其已有的邮件客户端向它写信。连接 Gmail 或 Outlook 的_账户_属于连接器，而不是入口。每个入口都会解析请求者是谁以及其可提出哪些请求；pod 则承载数据。

一个 pod 也适合单人使用。一个人类和少数几个 Agent，以 WhatsApp 作为前门、以表格作为记忆，就能构成一名个人助理：它保持状态、行动前询问，并在明天从今天中断之处继续。

你已经在使用的 Agent 会构建整个系统

应用、表格、Agent、工作流和权限，全部都由编写它们的同一 Agent 写成文件、导入并检查。构建和运维使用的是同一套 CLI。

Claude Code |
Codex |
OpenCode |
Cursor |
Antigravity
---|---|---|---|---

将 Lemma 的技能安装到你已经使用的 Agent 中：

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 directory

技能位于 lemma-skills/。安装后重启你的编码 Agent，将其指向一个空目录，并向它交代任务：

使用此工作区中可用的 Lemma 构建器技能，为**[描述任务]**构建一个完整应用。

从执行工作的人员及其所需结果出发，然后设计最小可用的运营闭环。

在 Lemma 上构建整个系统：人们打开并使用的应用、保存共享状态的表格和文档、推动工作的函数和工作流、可提供帮助的 Agent，以及包含人工审核点的清晰权限。

保持界面平静、针对任务而设计，并能让真实团队立即使用。在进行任何修改之前，先向我展示拟议的工作流和资源模型。

它会将表格、Agent、工作流和权限写成文件，导入它们，然后运行工作流，以检查它是否会在应暂停的地方暂停：

lemma pod init support-ops       # scaffold a starter bundle to edit (or: lemma agent|table|workflow init …)
lemma pod import ./support-ops
lemma apps deploy support-ops ./index.html   # deploy a no-build HTML app (or a Vite project dir)

**或者在 Lemma 内运行你的 Agent。**Agent Host 将本地 Claude Code、Codex、OpenCode 或 Cursor 连接到 pod：它从持久队列获取任务，经由 pod 流式传回工作过程，并在受保护操作前暂停于审批关卡。两个在同一 pod 上工作的 Agent 将共享持久状态、任务队列和运行历史。参见 Agent Host。

任何 Agent 都可通过 CLI 直接操作 pod：

lemma table list                 # inspect the data model
lemma record update tickets tkt_418 --data '{"status": "closed"}'
lemma agent run classifier "classify ticket tkt_418"   # agents take a message; lemma function run takes JSON
lemma workflow run refund-review     # returns as soon as it reaches a human approval step
lemma chat "what's left in the queue?"

如果你正在编码 Agent 会话中阅读本文：该 Agent 现在就可以操作一个 pod。

Python 和 TypeScript SDK（包含 25+ 个 React hooks）位于 lemma-python/ 和 lemma-typescript/。要在其他地方生成前端？为它接入一个 pod。TypeScript SDK 可让任何应用开箱即用地拥有表格、Agent、工作流和权限。

十个可以安装并据为己有的开源 pod。打开其中一个，了解它的构建方式，然后进行修改：

Pod | |
---|---|---
Roundtable | 团队运营 | 真实工作、共享上下文、人工判断
Frontdesk | 客户支持 | 每个请求均被路由、每个回答均有依据、每次发送均受控制
Panini | 写作 | AI 提议，人们决定，文档会记住
Smart Inbox | 个人效率 | 你的规则、你的语气、更安静的收件箱
Sidekick | 个人效率 | 了解日常惯例、记住上下文、行动前询问
Lemma Design | 设计 | 设计想法、原型化感受、将其变为现实
Nachiketa | 学习 | 从一个问题开始，从来源构建，通过尝试学习
**[Drop](https://github.com/deepak-jha-kgp/

---

A multiplayer, self-improving harness

A harness is everything around the model: the tools it can call, the memory it reads, the state it writes, the loop it runs in, and the boundary it works inside. Coding agents gave you a harness for one person, on one machine, for the length of one session.

Lemma is that harness for a team. State is shared and permissioned, so many people and many agents work the same records. It keeps running between sessions, on schedules, webhooks, and table events. And it compounds: corrections become standing instructions, sequences become workflows, judgment becomes an agent role. The harness your team uses next month is better than the one you ship today, because using it is what improved it.

Your coding agent builds it. Describe the job to Claude Code, Codex, Cursor, OpenCode, or Antigravity; it writes the whole system as files: the app people open, the tables underneath it, the agents, the workflows, and the permissions. Then it imports and verifies the result through the same CLI. Your team opens it at a URL, or reaches it from Slack, Teams, Telegram, WhatsApp, or email.

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.

The same stack, hosted, reachable by teammates and surfaces:

uv tool install lemma-terminal
lemma servers select lemma-cloud
lemma auth login
lemma skills install
lemma pod create support-ops --with-starter   # scaffolds a working starter (table + agent) and imports it
lemma chat "what can you do in this pod?"

Download Lemma Desktop, choose Local , and select Install local services. Lemma owns the local runtime and picks its own ports, so one bootstrap command reads them back out of Desktop and registers them with the CLI as the local server.

Run this after Desktop's local setup has finished once:

uv tool install lemma-terminal
curl -fsSL https://raw.githubusercontent.com/lemma-work/lemma-platform/main/install.sh |
  bash -s -- --cli-only          # registers Desktop's endpoints as the local server
lemma servers select local
lemma auth login
lemma skills install
lemma pod create support-ops --with-starter

Then open the generated support-ops/ directory in the coding agent you already use and describe the system you want. Full Desktop, Agent Host, and provider setup lives in Install in depth and docs/installation.md.

Use uv tool install, not pip. lemma-terminal needs Python 3.14, and uv tool install provisions that interpreter itself, so whatever python3 is on your machine does not matter. pip install lemma-terminal on an older interpreter does not fail — it quietly resolves back to 0.6.2, the last release that allowed 3.11, and installs a CLI several minors behind the server. lemma --version reports what you actually have.

If a command did not do what it says here:

Symptom	What to do
Server not found: local	Desktop's local setup has not run, or the bootstrap above was skipped. Run it, then lemma servers show to confirm which server is active.
Agents unavailable, or chat answers with a provider error	No AI provider has validated yet. Local Control Center → AI Providers ; Ollama or LM Studio if you have no API key.
Something works in the app but not in the CLI, or the other way round	lemma doctor — it diagnoses client/server version skew and duplicate installs.

One of it, however many of you

You share the agent itself, already running. Send someone the link; they open the same agent, and their work lands in the same records. There is one of it to fix, one of it to improve, and one set of records underneath.

Scoped to each person:

Who	Role	Access
Priya	Owner	Approves refunds, any amount
Marco	Member	His own jobs; refunds route to Priya
Classifier	Agent	Reads tickets; read-only

Same system, different rights. One version of it, for everyone.

Build it, ship it, and hand it to your team

01 · Build it where you already work. Claude Code, Codex, Cursor, OpenCode, or inside Lemma itself. The agent authors the tables, agents, workflows, permissions, and the app, then verifies them through the same CLI.

02 · The app and its agents go live together. One URL for the people who use it. The agents work on schedules, webhooks, and table events, and keep working while everyone is logged off.

03 · Bring your team, and anyone else who needs it. Teammates, clients, and guests each get an invite link, the app, and their own account inside the pod.

04 · Decide exactly what each one can touch. One permission model covers people and agents: per-table grants, resource visibility, and approval gates on the consequential steps.

05 · Use it from wherever you already are. Slack, Telegram, WhatsApp, and email. Or open it as an app. Every entry point reads and writes the same records under the same permissions.

Everything 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. This is where policy lives: versioned, editable, and read at run time.
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	The predictable half: same input, same output, every time. Plain code for validators, state transitions, and outbound actions. Agents call them as tools, so judgment and rules stay separable.
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. Days later, if that is how long it takes.
Connectors	Every connection shows the account, its access, and what uses it, so "the agent can email customers" is a setting you can see.
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. An agent writes, and the app is already showing it.
Surfaces	Slack, Microsoft Teams, Telegram, WhatsApp, and email, wired to pod agents with identity resolution and conversation linking.

The harness improves itself

Finished work leaves reusable structure behind. A triaged email becomes a record. Repeated corrections become standing instructions, repeated sequences become workflows, and recurring judgment becomes an agent role, with approval gates wherever people stay responsible.

However the work arrives, it lands in the same pod

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 by email and waits for a person before sending. The conversation is the surface; underneath, all of it reads and writes the same tables, runs the same workflows, and respects the same permissions.

Supported today: Slack, Microsoft Teams, Telegram, WhatsApp, and email. Each one has webhook ingress, identity resolution, and agent-initiated actions. Telegram long-polling and Slack Socket Mode connect local setups directly.

Every pod agent gets its own address, and anyone can write to it from whatever mail client they already use. Reaching a Gmail or Outlook account is a connector, not a surface. Each surface resolves who is asking and what they may ask for; the pod holds the data.

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.

The agent you already use builds the whole system

The app, the tables, the agents, the workflows, and the permissions. All written as files, imported, and checked by the same agent that wrote them. Building and operating use the same CLI.

Claude Code |
Codex |
OpenCode |
Cursor |
Antigravity
---|---|---|---|---

Install Lemma's skills into the agent you already use:

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 directory

Skills ship in lemma-skills/. Restart your coding agent after installing, point it at an empty directory, and give it the job:

Use the Lemma builder skills available in this workspace to build a complete app for [describe the job].

Start from the person doing the work and the outcome they need. Then design the smallest useful operating loop.

Build the whole system on Lemma: the app people open and use, the tables and docs that hold shared state, the functions and workflows that move the work, the agents that can help, and clear permissions with human review points.

Keep the interface calm, specific to the job, and ready for a real team to use. Before changing anything, show me the proposed workflow and resource model.

It writes the tables, agents, workflows, and permissions as files, imports them, then runs the workflow to check it pauses where it should:

lemma pod init support-ops       # scaffold a starter bundle to edit (or: lemma agent|table|workflow init …)
lemma pod import ./support-ops
lemma apps deploy support-ops ./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. See Agent Host.

Any agent operates a pod directly through the CLI:

lemma table list                 # inspect the data model
lemma record update tickets tkt_418 --data '{"status": "closed"}'
lemma agent run classifier "classify ticket tkt_418"   # agents take a message; lemma function run takes JSON
lemma workflow run refund-review     # returns as soon as it reaches a human approval step
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.

Ten open-source pods you can install and make yours. Open one, see how it was built, change it:

Pod | |
---|---|---
Roundtable | Team operations | Real work, shared context, human judgment
Frontdesk | Customer support | Every request routed, every answer grounded, every send controlled
Panini | Writing | AI proposes, people decide, the document remembers
Smart Inbox | Personal productivity | Your rules, your voice, a quieter inbox
Sidekick | Personal productivity | Knows the routine, remembers the context, asks before acting
Lemma Design | Design | Design the idea, prototype the feeling, make it real
Nachiketa | Learning | Start with a question, build from sources, learn by attempting
Drop | Capture | Send it once, find it later, keep the context
Meal | Wellbeing | Say what you ate, see the pattern, choose one next move
Lemma GTM | Go to market | Position clearly, build with proof, ship the campaign

Browse and install them at lemma.work/templates.

A pod is files. Export it, share it, remix it:

lemma pod export ./support-ops    # the whole system, as files
lemma pod import ./support-ops    # ship it back, or anywhere else

The same coding agent that built a pod can export, change, verify, and re-import it.

Open, local, and portable

• 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.

Download the signed online package from the latest release for macOS 14+ on Apple silicon, and drag Lemma to Applications before opening it. The small installer downloads digest-verified runtime components on first use; this release publishes the online package, and offline packages follow later.

There is no published Windows installer. Windows 11 23H2+ on x86-64 is built and signed every release, but the installer stays a workflow artifact rather than a release asset: attaching it would be an offer of support we cannot make until the Windows paths have been tested end to end. Getting it takes a GitHub account and the Actions UI — steps in installing on Windows.

Choose Local , select Install local services , and create the local owner inside the app. Lemma owns its lightweight VZ/WSL2 runtime and installs everything it needs itself: one download, one app. 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. See the complete local installation and operations guide.

The CLI ships knowing one server, lemma-cloud. Because Desktop's ports are chosen per installation, the local server is written from what Desktop actually allocated rather than assumed. The stack-control bootstrap installs lemma-stack and does that in one step:

curl -fsSL https://raw.githubusercontent.com/lemma-work/lemma-platform/main/install.sh |
  bash -s -- --cli-only

--cli-only is what registers local; without it, install.sh starts the Docker/Podman compatibility install instead, which Desktop users do not want. Run it after Desktop's local setup has completed once — it reads the endpoints from the running installation, so it fails if there is nothing to read.

Lemma Desktop is for one person's machine. To run Lemma for a team on a VM you control, there is a production Docker Compose stack:

git clone https://github.com/lemma-work/lemma-platform.git
cd lemma-platform/deploy/compose && ./bootstrap.sh && docker compose up -d

It brings up the API, the worker, Postgres, Redis, SuperTokens and a Caddy front end from images pinned by digest, and serves on <your-ip>.sslip.io until you point a domain at it. The full guide is self-hosting on a VM; one-click templates for DigitalOcean, Hetzner, Render and Railway are in deploy/.

To let a 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 those coding agents.

In Lemma Desktop, open Models and press Connect this computer , then Add to chat models on the agents it finds. The app pairs itself as you: one click, and this machine is paired. Desktop supervises Agent Host, so pairing, starting, stopping, and updates all happen there, and lemma runtime profiles list shows the profiles it created. Point any agent at one:

lemma agent update <name> --data '{"agent_runtime": {"profile_id": "<profile_id>"}}'

Agent Host runs on the machines Desktop runs on (macOS and Windows), and drives each coding agent over the Agent Client Protocol. Antigravity (agy) installs Lemma's skills and authors pods today; pod-dispatched runs arrive with its ACP support.

A provider for server-run agents and conversations

Use Local Control Center → AI Providers , or apply the same transactional configuration through lemma-stack (the stack-control CLI, installed by the bootstrap above — it is not on PyPI):

lemma-stack config set ai.protocol=openai_compat ai.base_url=http://127.0.0.1:11434/v1 ai.default_model=qwen3

Secrets 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.

No API key? Point it at a model on your own machine instead: start Ollama or LM Studio and press Ollama or LM Studio in Local Control Center → AI Providers. Server-run agents stay unavailable, with the reason shown, until some provider validates.

Path	Package	License
lemma-backend/	FastAPI backend, sandbox images and runtime, migrations, and infra Docker Compose	AGPLv3
lemma-frontend/	User-facing workspace	AGPLv3
lemma-harness/	Operator tools and desktop web runtime	AGPLv3
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
lemma-pod-bundle/	lemma-pod-bundle, the pod bundle format, shared by the CLI and the backend	Apache-2.0
docs/	Installation, configuration, architecture, and security documentation	n/a
install.sh	Bootstrap for lemma-stack. --cli-only registers Desktop as the CLI's local server; with no flags it runs the Docker/Podman compatibility install	n/a

Everything is a normal directory in one repo. ARCHITECTURE.md explains how the pieces fit together.

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 the sandbox runtime 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, the sandbox runtime, and tunnel processes
make stop-all    # also stop dev infrastructure

Run 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 migrate

Start at docs/. It indexes everything. The most-used entries: installation for the full setup guide, configuration for what every setting does, ARCHITECTURE.md for how the components fit together, CONTRIBUTING.md for what a pull request needs, and lemma-backend/README.md / lemma-harness/README.md for per-component detail.

The Lemma platform uses a dual-licensing model:

AGPLv3 (server-delivered core):

• lemma-backend/: the FastAPI backend, including the sandbox images and the runtime that ships inside them
• lemma-frontend/: the user-facing workspace (make dev-frontend)
• lemma-harness/: operator tools, auth portal and desktop web runtime

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):

• lemma-stack/: local stack installer and manager
• lemma-cli/: the lemma CLI and terminal UI
• lemma-python/: the Python SDK
• lemma-typescript/: the TypeScript SDK
• lemma-skills/: agent skills
• lemma-pod-bundle/: the shared pod bundle format

These are intended for broad embedding, installation, and adaptation, so they remain Apache-2.0 and include their own LICENSE files.

lemma-pod-bundle is Apache-2.0 rather than AGPLv3 on purpose: it is the dependency-free vocabulary that lets the Apache-2.0 CLI and the AGPLv3 backend agree on the bundle format while each stays independent of the other, and it is vendored into the published lemma-terminal wheel.

Commercial licensing and exceptions are available from Folks and Machines, Inc. for organizations that require a commercial licence. The commercial exception clears the AGPL procurement question while keeping the core genuinely open source.

Trademark: The Lemma name, logos, and marks are trademarks of Folks and Machines, Inc.; the software licenses grant rights to the code alone. Fork the code, not the brand.

Lemma is built by Folks and Machines, Inc., a Delaware corporation. © 2026 Folks and Machines, Inc.