Lemma: Open-Source Workspace Your AI Agent Actually Lives In

Ever had your Claude Code produce a killer analysis, scroll past it three messages later, and realize you can’t find it again without dumping the whole terminal history? Yeah, me too. I’ve been running coding agents for months now — OpenCode, Claude Code, Goose — and the single biggest pain point isn’t the quality of their work. It’s that their work lives in a chat scrollback that evaporates the second your session ends.

So when I found Lemma — an open-source workspace that treats AI agents as first-class team members alongside humans — I had to test it. 214 stars in 10 days, dual-licensed (AGPL core + Apache SDKs), and the tagline “chat is not where work lives” basically called me out personally.

The short version: Lemma is a shared workspace (they call it a “pod”) with typed tables, agents that own tasks, workflows with human approval gates, and role-based permissions — all readable and writable by both humans and agents through the same API. And you can self-host it with Docker Compose or use their cloud. And it plugs into Claude Code, Codex, OpenCode, or Cursor without needing a separate API key.

What Is Lemma, Really?

Here’s the philosophy: AI agents can write code, research topics, and call tools all day. But a chat thread isn’t a place where work can live. Real work has owners, state that persists for days, steps that need human decisions, and actions an agent should never take alone.

So Lemma solves this with pods — portable directories of plain files that contain everything a team (human + agent) needs:

• Tables — typed, queryable business data with row-level security. Leads, tickets, tasks, approvals. Agents read and write them natively.
• Files — markdown memory for everything structure can’t capture. Preferences, playbooks, voice guides. Full-text searchable.
• Agents — LLM workers with a role, tool grants, and scoped access. Never vague access to everything.
• Workflows — graphs that mix agents, functions, decisions, loops, and human approval steps. Triggered by schedules, webhooks, or chat.
• Permissions — roles for people and agents. Pod-level roles, table grants, delegation tokens.
• Surfaces — Slack, Teams, WhatsApp, Telegram, Gmail. Same pod, different front doors.

So that’s a lot of primitives. But in practice, it clicked for me when I actually set one up.

Installation & My First Pod

I installed this on a $6 DigitalOcean Droplet (2GB RAM, Docker pre-installed). The install command is dead simple:

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

So that gives you lemma-stack — a tool that manages the full backend + frontend stack. Took about 2 minutes on a fresh Droplet.

Then I set up an API key and started the stack:

lemma-stack config set LEMMA_DEFAULT_MODEL_TYPE anthropic_compat
lemma-stack config set LEMMA_ANTHROPIC_API_KEY sk-ant-...
lemma-stack start

Now, this boots the app at http://127-0-0-1.sslip.io:3711 and the API at http://127-0-0-1.sslip.io:8711. But one thing that tripped me up: you must use the 127-0-0-1.sslip.io hostname, not localhost — sign-in is scoped to the sslip.io domain. Took me a solid 3 minutes to figure that out.

Once the stack was running, I installed the Lemma CLI and connected it:

uv tool install lemma-terminal
lemma servers select local
lemma auth login
lemma pod create my-team --with-starter

So the --with-starter flag scaffolds a working pod with one table and one agent. And I ran lemma chat "what can you do in this pod?" and the agent walked me through every table, workflow, and permission it had access to. Honestly? That moment — an agent describing its own workspace boundaries — was the first time I felt like I was working with an agent, not just querying one.

What Running a Pod Actually Looks Like

So the best way to explain Lemma is by example. After I created my starter pod, I used the CLI to inspect it:

lemma table list
lemma record create leads --data '{"name": "Acme Corp", "status": "new"}'

So the agent can see that new record. So I asked it: “qualify this lead.” It ran a workflow — checked the company size, looked up industry, scored it — and wrote the result back as a row update. I reviewed it, hit approve, and the agent moved on to the next step.

But here’s what I found interesting. I opened Claude Code in another terminal, had it install Lemma’s skills (lemma skills install), and then Claude Code could operate the same pod. Two agents, same state, same permission model. That’s something no chat-based workflow can do.

And if you want to run your agent inside Lemma full-time:

lemma daemon start

So this makes your local agent (Claude Code / Codex / OpenCode) pick up tasks from the pod’s shared queue, stream its work back through the pod, and respect the same approvals as everyone else. And I ran this with Claude Code and it worked — though it’s early-stage software, so expect a bit of rough edges around error handling.

How Lemma Compares to Other Agent Tools

So let’s put it side by side with the tools I’ve covered on ToolGenix:

So where does Lemma fit? If you’re using junction to control 7 agent backends from one VS Code sidebar, Lemma is the next logical step — it gives those agents a workspace with state, permissions, and human oversight. And if you’ve deployed agents on a VPS using a setup guide like the Hermes one, Lemma is the layer that turns your agent from a CLI command into a teammate with a job description.

Self-Host or Use the Cloud?

Now, Lemma gives you both options, and the choice is straightforward:

• Self-host (Docker Compose): Full stack runs on any machine with Docker. I used a $6 DigitalOcean Droplet and it handled the whole platform — backend (FastAPI), frontend (Next.js), and agent runtime. You’ll want 2GB+ RAM minimum.
• lemma.work cloud: Same open-source stack, hosted by the team. No infrastructure to manage. Uses your existing Claude or ChatGPT subscription — no separate per-token billing.

And the local-first design means you can start on your laptop, export the pod as files, and import it on a VPS or the cloud. Pods are just directories — lemma pod export ./my-team gives you the entire workspace as plain files.

Who Should Use Lemma?

Best for: Teams already running Claude Code, Codex, or OpenCode who want structured agent output — tables instead of scrollback, approvals instead of trust-based execution, permissions instead of “the agent can see everything.”

Skip if: You work solo and your agent workflow is “ask a question, get an answer, close the terminal.” Lemma’s value is in shared state and team coordination, and solo use doesn’t need most of it.

So here’s the honest caveat: 214 stars, 10 days old. The docs are evolving — the installation page covers the basics well, but workflow configuration and the approval gate pattern could use more examples. I hit the 127-0-0-1.sslip.io gotcha, and the daemon mode threw a couple of unhelpful error messages. This is early-stage software with a clear vision but room to grow on polish.

The Bottom Line

Still, Lemma fills a gap I didn’t realize existed until I tried it. Because we’ve been putting AI agents in chat interfaces and pretending the scrollback is “state.” But it’s not. Lemma gives agents a real workspace — tables, permissions, approvals, and surfaces that humans actually use. For anyone building serious agent workflows, it’s the most interesting open-source project I’ve found in this space this month.

And I’ll be running it alongside my normal agent setup and watching how the project matures. Still, the vision is solid, and the execution is already usable for teams that want structured human-agent collaboration today.