Masscode
Masscode Download
The governed AI development lifecycle

From clear intent to proven code, with any model.

Masscode is an open source AI development lifecycle. It turns what you want to build into clear requirements and decisions, then has coding agents deliver the work under rules a program can check.

Free and open source Soon on GitHub Contributions welcome
The Masscode cockpit: every project with its progress, reviews waiting, parked tasks and spend against budget. The Masscode cockpit: every project with its progress, reviews waiting, parked tasks and spend against budget.
The value

Most of what software costs is decided before the first line of code. Masscode puts its effort there, then proves the code kept those promises.

Five pillars

What sets Masscode apart.

01Decision support

Clear requirements from the first conversation.

Masscode starts with why the project exists, then the features that serve it, then requirements with measures and non goals. Decisions come one at a time, each briefed by an advisor that researches current sources and draws the diagram you need.

  • Each brief shows only the facts that decision touches, with two or three options and what each one opens and closes.
  • Routine decisions are accepted in a batch, so your attention goes where it matters.
  • A decision reopens by itself when a measurement crosses one of its assumptions.
A decision reopened by a measurement, with its brief, the requirements it serves and the documents the cockpit is reading. A decision reopened by a measurement, with its brief, the requirements it serves and the documents the cockpit is reading.
The decision graph: settled, open and reopened decisions and what each one leads to. The decision graph: settled, open and reopened decisions and what each one leads to.
In the cockpitD-05 reopened when the graph grew past its recorded limit.
02Rule enforced decision graph

A project graph that enforces its own rules.

Objectives, requirements, decisions, constraints, tasks and tests are typed facts in one graph built on open standards. Rules check the graph when work is defined and again when code lands, so what was agreed stays agreed.

  • Every accepted decision emits a constraint that a program checks.
  • A rule that rests on an unapproved term answers unknown, and unknown never counts as a pass.
  • Every gate is a signed commit in your repository, with readable decision records and an evidence bundle for each merge.
NIST 800-53ITSG-33ISO 27001PIPEDALaw 25
The rules of a project with their verdicts: passed, failing, unknown and waived, and where each rule applies. The rules of a project with their verdicts: passed, failing, unknown and waived, and where each rule applies.
In the cockpit13 rules, each with its verdict and the parts of the system it governs.
03The failure mode

When something goes wrong, it stops and tells you why.

Each task runs in a sealed sandbox that may only write to its own folders. A separate agent writes the tests, programs run the checks, and a reviewer reads the change before you approve it.

  • Anything unusual parks the task with the reason and your options. It never guesses its way forward.
  • Repair rounds and budgets are capped by risk tier, and a test that did not run is never a pass.
  • Every failure is logged and becomes a lesson for the next run.
Delivery: tasks laid out by wave, with merged, in review, parked and blocked tasks. Delivery: tasks laid out by wave, with merged, in review, parked and blocked tasks.
Failures and improvements: what went wrong, where, and what it cost. Failures and improvements: what went wrong, where, and what it cost.
The review queue: critical tasks waiting for a person, with the frontier model's opinion. The review queue: critical tasks waiting for a person, with the frontier model's opinion.
In the cockpitWave 2 of 3: seven tasks merged, one parked for a person.
04Open and sovereign

Any model, any environment, nothing locked in.

The engine is open source and runs on one machine under Docker, in your private cloud or fully offline, so regulated data stays in the jurisdiction you choose. Pick a model for each role: Claude, OpenAI, GitHub Copilot, or a local model through LM Studio, Ollama or vLLM.

  • A role you keep local never falls back to the cloud. It waits instead.
  • Secrets go to a broker, and no agent or model ever sees them.
  • Works with GitHub, Linear and Jira, and exposes its contracts through OpenAPI and MCP.
New project, agents step: choosing local, mixed or cloud models and where each model is reached. New project, agents step: choosing local, mixed or cloud models and where each model is reached.
New project, repository step: the code host, the tracker and the scoped identities the factory uses. New project, repository step: the code host, the tracker and the scoped identities the factory uses.
In the cockpitLocal models write and test code. Hosted models are an explicit choice.
05Token and cost reduction

Fewer tokens, predictable spend.

Agents get small, fenced tasks with only the context they need: a map of the code instead of the whole repository, and a slice of the graph instead of the whole project. Programs settle what they can, so models are asked only about the rest.

  • Routine work runs on local models, and paid models are kept for the reviews that need them.
  • Every call is priced and attributed to a project, a task and a cause, rework included.
  • At a project's cost cap, new tasks wait until you raise it.
A project's costs: budget used, forecast, spend on failures and retries, and what was paid for by activity and by provider. A project's costs: budget used, forecast, spend on failures and retries, and what was paid for by activity and by provider.
The cost center: spend of every project against its cap, split into definition, build, review, rework and CI. The cost center: spend of every project against its cap, split into definition, build, review, rework and CI.
In the cockpitRework is shown in its own colour, so waste is visible at a glance.
How it runs

Six stages, each ending at a gate you approve.

  1. 01

    Onboard

    A few questions set the project type, review level, models and cost limits.

  2. 02

    Define

    Objectives, then features, then requirements with measures.

  3. 03

    Decide

    Architecture, data, security, testing and design.

  4. 04

    Break down

    Tasks grouped into waves by a solver.

  5. 05

    Deliver

    Implementation, tests, checks and review for each task.

  6. 06

    Prove

    Each merge carries its evidence into the graph.

Open source

Free to use. Better with you on board.

Community edition

Everything, for free

Freeopen source under GPL-3.0
  • The complete engine: cockpit, orchestrator, graph, verifier and sandboxes
  • Every model source, every rule and every gate
  • Runs on your own machine with Docker, fully offline if you need it
Download Masscode
On GitHub

Star it, then help build it

A star helps other teams find Masscode. Contributions shape where it goes next, and some of the most useful ones need no knowledge of the whole engine.

  • Language adapters that read a new language into the ten code fact types
  • Decision templates for the backlog catalogue, from your own practice
  • Rules and control profiles, each with a passing and a failing fixture
  • Cockpit screens, documentation and French translations
Star on GitHub Contribute
Download

Start your first governed project.

The installer sets up the stack on your machine and opens the cockpit. You can look around before any model is configured.

Needs Docker DesktopAbout 12 GB of free diskLocal models need at least 32k tokens of context
Or from source
# from the repository $ git clone https://github.com/MasscoreAI/Masscode $ cd Masscode && make up $ open http://localhost:8080