MLambda Turing

What it is

An application factory built on the Genesis workbench. A project name and a prose description go in; a formal domain, a model-checked specification, and a generated, tested, containerised system come out. It is not a prompt with a code generator behind it: the language model acquires content, rules admit it, and what is missing is derived rather than guessed.

What is built

Turing is the front half — the workbench you see below: backlog, requirements, use cases, model, screens, source, scenes and chat tracing in one surface — plus a society of agents that negotiates the domain and Gears, the build engine that coordinates them through declared workflows. Bet is the back half: it emits the actor system, the data layer and the UI from the specification, and Tsadi derives the test obligations from the model instead of searching for them. Thinker is the reasoning layer underneath both — pluggable LLM providers and retrieval acquire knowledge; a deterministic grammar formalises it; a forward-chaining engine proves over it; a proof kernel re-checks; a symbolic reinforcement learner improves what is believed over time. The LLM never answers. Only proofs do.

Alongside it, MLambda.Actor.Agent packages the same method as a Claude Code plugin: 17 specialised agents — research, conceptualisation, formation into Z, production planning, sequence modelling, failure analysis, TLA+ verification, code generation, BDD testing, benchmarking, cleanup, cluster deployment, integration demo, application architecture, topology deployment, diagnostics, release — that take a business description to a deployed actor system on the MLambda runtime.

Where it came from

Turing is the realisation of a mission its founder carried for years before MLambda existed: a system that understands architecture the way TOGAF describes it, expresses each domain as a domain-specific language, and runs it on an actor framework built for reactive domain-driven design. The rational tools that make it up divide the work cleanly — language models gather and validate requirements in a controlled language; symbolic artificial intelligence infers the logic, the views, the tests and the verification from what was admitted. Genesis runs TOGAF’s cycle; Guimel is the domain language; MLambda.Actors is the runtime the domains run on.

The story

What follows is one small system — a to-do list — going through Turing, as the workbench shows it.

It begins with a backlog that knows what it does not know. Features carry goals and quantified objectives — 95% of tasks created conform to defined attributes — because a requirement without a scale and a target cannot be verified, only argued about. The banner at the top is the first thing Turing tells you: the domain is not yet sound. Design, Implement and Deploy are there, and they will not run until it is.

Then the words are fixed. A requirement in Turing starts with the ubiquitous language: these are the terms the system is described in, and no others. Each is typed — persona, command, value, specification, event, entity — and each says where it came from. The use case that follows has a trigger, an intent, a guard, and a refusal: what happens when the title is blank is not an edge case someone remembers later; it is part of the requirement.

The diagram is derived, not drawn. One actor, two use cases, an extension for the refusal — generated from the requirements alone, with the documentation table filled in by the same analysis that wrote the requirement. If the picture and the words ever disagreed, one of them would be wrong; here they cannot, because one is computed from the other.

Then it becomes a model — and the model refuses to guess. The domain is composed into Guimel: personas, a context, entities, events, commands, specifications, a repository, an aggregate whose handler allows a persona, requires a specification and emits an event on refusal. Read the comments. Shape not stated: nothing says what TaskCreationFailed carries, so it carries only the identity of what it is about. Name its fields in the requirement. A missing requirement is an unfulfilled obligation. The system points at it; it does not paper over it.

Screens are composed, and the suggestions cite their evidence. Pencil builds the interface from canonical layouts and a component palette. Its suggestions are not taste: Pagination accompanies Table in 95% of this repository’s own wireframes — source named, measured or estimated stated. An observation that would change nothing says so and takes no action.

Only then is there code. A TaskActor on MLambda.Actors — sharded by id, state restored on activation, a Receive behaviour that switches on the commands the model declared, handlers that return the events the model declared — with the .samek specifications, the project file and the Kubernetes deployment generated beside it. The comment in the handler says convention-synthesized: the body carries no computation the specification did not already imply. The system you get was true before it existed.

How to get it

Turing is not yet a public download. Teams evaluating it can request early access; the architecture and the method book are public on the Genesis documentation site.