What is Lumis?
Lumis is an operating system for getting software built: you say what you need, a crew of AI agents plans it, builds it, checks it, and lines it up for your approval — and every step leaves a record you can go back and look at.
The shift
Most software is a tool: it sits there until you open it, and you still do the work yourself. Lumis works the other way around. You describe what needs to happen, and a crew of AI agents does the work on your behalf, while you watch. Nothing happens behind a “thinking…” spinner or inside a chat you can’t return to later. We call this working in glass: every action any agent takes is visible and traceable, not locked away where you can’t see it.
A worked example
Here’s what that looks like for one small, real problem.
You notice something
“The signup confirmation email is landing in spam.” You say that once, wherever you’re already working. There’s no form to fill out. Lumis captures it as a ticket — a tracked record with a title, why it matters, and a status — the moment you say it.
A planner scopes it
Before anyone touches code, a planner agent turns your one line into a plan: what “fixed” actually means, which files the fix is allowed to touch, and what else it depends on. That plan attaches to the same ticket.
A builder fixes it, on its own branch
A builder agent picks up the ticket and makes the change on a branch of its own — never directly on the code everyone else is using — and stays inside the files the plan allows.
A different agent reviews it
Once the fix is built, a reviewer checks it, and it’s never the same agent that wrote the fix. The reviewer runs the tests, confirms they pass, and records that result on the ticket.
It lands in your queue
The ticket moves into your review queue carrying the diff and the passing tests, so you’re looking at the real change, not a summary someone wrote about it.
You approve, it deploys
Nothing goes live without you. You approve, the change deploys, and the ticket closes.
Every one of those six steps wrote a record to the database the moment it happened: who acted, what changed, what passed. Nothing here lived only in a chat window and then disappeared.
The four ideas that make this trustworthy
- The crew — a small organization of specialized agents, not one general assistant, each with a defined role and a clean handoff to the next.
- Evidence — nothing is marked done because an agent says so; it’s marked done because a test, a diff, or a check proves it.
- Gates — agents act on their own inside their lane; deploying, spending, and anything hard to undo always stops for you.
- One source of truth — every ticket, plan, and record lives in one database, not scattered across files, chats, and wikis that drift out of sync.
One platform, many projects
Lumis itself is one platform: the rules the crew follows, the crew itself, and the loop work moves through. Every project you bring in — an app, a website, a service — plugs into that same platform instead of carrying its own copy of the rules. Think of it as one place holding everything shared, and each project connected to it: each carries only its own code plus a short pointer back to the platform. Add a second project, and it inherits the same crew, the same loop, and the same gates on day one. Improve something once at the platform level, and every project feels it.
Read next
The crew — meet the agents who do the work, and how a request moves between them.