Software companies have to adapt. The six phases we all learned still hold, but every one of them assumed a person did the work. This is how LUM keeps the agents productive and the code trustworthy at the same time: one framework, roles with hard limits, and a human at every gate.
Code got cheap. An agent can write more of it, faster, than any team you could hire, overnight, for a fraction of the cost. That single fact splits every software company in two.
Refuse the agents, and you cannot compete on price or speed. Unleash them, and you drown in code nobody can maintain. Neither side wins on its own. The firms that last will be the ones that find the balance, productive agents and trustworthy code, and make it repeatable.
When code is cheap, the problem moves to three things.
The framework. One bounded stack: TypeScript, Postgres, a shared library of capabilities with contract tests, and written principles. Every project starts the same and stays maintainable, so anyone, human or agent, can fix any of it. The moat compounds with every capability added.
The run. Skills that carry a feature from idea to pull request. A coordinator drives explorers, designers, builders, reviewers, and a witness, each a role with its own model and effort. You decide at three gates; everything between is governed agent labor.
The platform. The orchestrator starts each step, shows the work live, and keeps what the run produces. Agents run on the member's own machine via the lum program; the sign-in never leaves their computer.
Every feature travels one fixed path: Grill → Spec → Tickets → Build → Review → Prove → Merge. The agent grills you until what to build is settled (gate ①, you confirm); it writes the spec, with a threat model when the work crosses a trust boundary (gate ②, you approve); it splits the spec into the fewest tickets the blockers allow; one builder per ticket writes the failing test first; each ticket is reviewed until clean, with fixes by a fresh fixer; a witness starts the app and shows each behavior the way its user would; and the pull request opens as a report (gate ③, you merge).
Your time goes to three things: confirm the grill, approve the spec, merge the pull request. Everything between is governed agent labor, and it leaves evidence.
A coordinator drives the run; each other role does one job, with its own model and effort and hard caps on time and spend. None can approve its own work or merge to main.
| Role | Model | What it does |
|---|---|---|
| Coordinator | best | Drives the run end to end, dispatching each role and holding the thread from grill to pull request. |
| Explorer | utility | Read-only research for another role. Returns an answer with references; writes nothing. |
| Designer | best | Turns the settled intent into the spec, the threat model when a trust boundary is crossed, and the tickets. |
| Builder | worker | One per ticket, each in its own working copy. Writes the failing test first, then makes it pass. |
| Reviewer | best | Reviews each ticket against repo standards and the spec until it is clean, from a different vendor than the writer. |
| Fixer | worker | A fresh pair of eyes that resolves review findings the builder shouldn't grade itself on. |
| Witness | utility | Starts the finished app and demonstrates each behavior exactly as its user would, before you ever look. |
Model agnostic by design. A role names a model class (best, worker, utility), never a vendor. LUM runs any model with API access, Claude, GPT, Gemini, or open-weights, on your own keys; Claude Code and Codex are today's harnesses. Run the designer on Anthropic, the builder on OpenAI, the reviewer on Google, any mix you prefer, and swap when a better model ships. The reviewer always runs on a different vendor than the writer, on purpose.
Authority does not live in a prompt an agent could talk its way around. It lives in the tools: branch protection, a hook that denies edits to protected paths, a check that fails a diff outside the plan's module, one secret per run, hard caps.
Never main, never a force push. A human approves every merge.
It cannot approve or merge its own work, or change the rules, the review file, or its own budget.
No production data, no deploys, no client contact.
Time, turns, and spend are bounded; when a cap is hit, the work is pushed with a note and a person is told.
One rule at a time, earned, never assumed.
Twenty-five years of combined time building production software, poured into guardrails the agents cannot step over. Every project has the same shape, one bounded, vetted stack; a shared library of capabilities behind interfaces; a project template; written principles, so people and agents move between projects without relearning.
The result is code a person can read, fix, and trust. Explicit over clever. No magic. Any team member can hotfix anything, with or without an agent. That is the bar the checks defend on every pull request.
A mistake is only worth making once. When a review or an incident turns up a lesson, it enters at the lowest rung that can hold it, and never higher. The system improves; the instructions stay short.
When it is mechanical, a tool enforces it. No one has to remember.
When it is a behavior to keep, a failing test guards it forever.
When it concerns one job, it goes in that role's or specialization's instructions.
Only when it applies to every run, and only after it has happened twice.
The platform starts each step of the run, shows the work live in a rich view, and keeps what the run produces: decisions, fixes, proof, risk. You watch progress and decide at the three gates; everything between runs on its own and leaves evidence.
It is local-first. Agents run on the member's own machine via the lum program; the sign-in never leaves their computer. Each run gets an isolated folder, a guard hook on every command, and sandboxed execution, so the agent's output is governed before it exists. The whole platform was independently security-tested end to end with the Mythos model.
An illustrative example: a clinic asks for a report of patients whose import email differs from the portal email, flag them, do not merge them. The tension is in the detail; the grill settles it and the tests hold it.
Not a tool bolted onto an old process, the process itself, rebuilt for a world where code is cheap. Productive agents and trustworthy code, at a price a business can actually pay, with the code, the context, and the reasoning owned by you.
This methodology is not only how the platform runs; it is what LUM Studio sells. The Studio is the implementation arm: consulting and custom software development where every engagement inherits the framework, the agent roles, and the human gates, from a net-new build to taking over a legacy system to installing the guardrails in your own team.
The two arms feed each other. Studio engagements fund and sharpen the platform; the platform makes every Studio engagement faster and more trustworthy than a consultancy starting from zero.