1. Premise
Current premise: agent-native development (18 Sep 2026)
Robert clarified and approved this direction in the lead discussion. Mo is a functional, statically typed, compiled language and runtime for agents as the authors and readers of code. Humans specify outcomes, authority and acceptable risk, and judge behavior and evidence; human source review is not a prerequisite. Mo is another option, influenced by Elixir/Erlang and the BEAM, not their replacement.
The primary product is the complete agent loop: discover, understand, edit, check, run, inspect, repair, verify. Prioritize fast, accurate, actionable feedback and version-correct, task-local learning for existing features before language expansion, except where a missing capability blocks a representative application. Measure time and total cost to independently verified behavior, not merely compilation speed or an agent’s completion claim.
The language is not just syntax. Types, explicit results, capabilities and process semantics express obligations; the runtime implements them; tools make them discoverable and observable. Keep plain source with targeted semantic operations. MCP or a similar protocol can expose authoritative compiler/runtime services; it does not replace them. Preserve the core while testing targeted revisions, not undertaking a wholesale syntax redesign. These are priorities, not a claim that the planned tooling already exists or that compiler checks prove intent.
Evaluate both cold discovery and a short introductory guide. Later, compare models, including affordable and open-weight models, on reliable outcomes, repair cycles, time and full cost including failures and assistance. Smaller-model success is a goal, not an established result. Open weights, model size and price are separate dimensions. Comparisons with supported existing languages reveal tradeoffs; Mo need not win every axis to be useful.
Program 7 is on hold. Robert explicitly superseded its BEAM-superiority thesis and associated runtime-claim retirement framing (S-A/S-B/S-C). This is a prospective change of goal, not a pass, a failed-rule erasure, or an alteration of old measurements. The sealed program specifications and auditor rules remain historical records. Correctness and safety obligations are not waived. The capabilities rule and the separate generation-ten contract-catch rule are not retired by this decision; program 7 execution, including its capabilities evaluation, is suspended. Replacement scope, metrics and acceptance criteria remain to be agreed and versioned before any new experiment.
Implementation remains paused until Robert explicitly approves starting and the lead confirms readiness. The four research reports have been reviewed with the oracle; agent-native-research-synthesis records supported findings, source limitations and a proposed maintenance-workflow trial. Neither that trial nor a new syntax, security strategy or replacement program 7 is ratified by this chapter. External reviews may challenge everything, including the need for a new language/runtime; agent-native-independent-review-prompt is the shared brief. The roadmap and appended decision-log rows record the current boundary.
Historical premise through the morning of 18 Sep 2026
The sections below preserve the earlier claims and their evidence. Their ordering, human source-review assumptions and program-7 superiority framing are not the current product direction. Unmet evidence remains unmet.
The world Mo was framed for
- Agents write nearly 100% of the code. Humans no longer write or closely review bodies.
- Humans still read. They read intent, contracts, effects, and what the toolchain has verified. That layer is the spec altitude. Bodies are the implementation altitude, collapsed by default.
- Since review is gone, trust comes from what the compiler and the runtime can check, not from what a person promised. The source carries its own evidence.
- Every third-party package is code nobody read. The supply chain is the largest attack surface a program has, and an agent that installs what it needs makes it larger.
The thesis (session 6, 14 Sep 2026)
Mo exists so that software written by agents is reliable, and needs no third-party code. Three layers deliver that, in the order of how much they carry:
- The runtime and the process model. Isolated processes, each an Elm-shaped state machine, supervised; a failure model that says what a crash discards, what a timeout leaves, what a restart loses, and when a reply is durable (chapter 3); a deadline on every wait, a bound on every mailbox, an overflow that is a bug; a ring of structured runtime events and a runtime surface an agent can query and, with the capability, act on (directions 37 and 40). This is where reliability comes from, and it is what no existing language can be retrofitted with.
- Capabilities, and recipes as the package shape. Authority is a parameter: a function is pure unless it takes a capability, a process holds only what it was started with, and nothing enters a program that
maindid not hand it, so a package’s authority is visible at install and provable at compile time (chapter 6). A recipe is a package at spec altitude, its bodies generated and checked against its tests; a brick is audited platform code. This is where zero dependencies comes from. - The language. Its job is to expose the first two at spec altitude so a human can read the contracts, the
neverclauses, theinvariants, and theverified:line without reading bodies, and so an agent gets a diagnostic instead of a bug. Functional and procedural, no classes; immutable values withvarandinoutand no aliasing; static types declared at every boundary and inferred inside; two kinds of failure that never cross, an expected failure as a value and a bug as a crash; one static binary; a formatter with one answer. The syntax is Elixir-shaped (end-closed blocks,?predicates, dot-call sugar) under Ruby’s taste, and spends novelty only where the semantics need it.
The language is not the thesis; it is the surface of the thesis. The language makes the runtime’s guarantees visible in the source; the runtime makes the language’s guarantees observable at run time. Mo’s bet is that agents write better systems when the machine and its source share one vocabulary. A law belongs in the language when it removes a class of bug (bounded loops and waits, sized integers, consumed results, no escape from an error into a handled outcome, capabilities that cannot be forged). A rule that counts lines is a project setting with a default, not a law (session 6, after round 6 and the outside review of 14 Sep).
What is measured
Nothing here is final until measured (direction 28). The claim under test is a conjunction: reliability at zero dependencies. The baselines run with the strongest checks their ecosystems offer, bought with packages and tools; Mo must match them on defects while needing none of it, and a baseline that is as reliable at zero run-time dependencies refutes the reliability claim, not the dependency one (Robert, 15 Sep 2026; decision log). The control run (chapter 8) predicts, in this order: how many defects a hidden adversarial suite finds in the finished program; how fast the program runs and how much memory it holds, native, against Go and Python; how fast the loop is from an edit to a verdict; and how many third-party packages and tools the program needs. How long an agent takes to write Mo is recorded, not predicted: no model has seen Mo in training, and that cost is expected and not the point (Robert, 14 Sep 2026).
The null hypothesis
The null hypothesis, on the thesis as restated: the BEAM with Elixir already gives most of Mo’s runtime advantages (isolated processes, supervision, a mailbox per process, hot code loading, a live shell into a running system), and the delta Mo adds (static types at every boundary, capabilities that cannot be forged, a deadline on every wait, one static binary, no package ecosystem to trust, an agent-facing runtime surface) does not justify a new language. This is the objection an OTP reader raises first, and it is the one program 7 must answer: a long-running service with a capability-scoped supply chain, measured against an Erlang or Elixir counterpart on reliability under a hidden defect suite, speed and memory, the loop, and dependencies. If the delta does not show there, that result changes the project.
What “does not show” means is written down before program 7 exists. On 17 Sep 2026 Robert ratified three stopping rules, drafted by an independent auditor that reads the raw evidence and never the lead’s reading (audit/README.md): one for the runtime layer (five reliability rows and four cost rows against Elixir on program 7, with the retirements S-A, S-B, S-C named in advance), one for capabilities and recipes (zero dependencies, recipe drift, capability escapes, maintenance time, with T-A, T-B, T-C), and one for the language layer’s catch claim below (read at erosion generation ten). The lead and the auditor each read the evidence alone, and Robert reads both.
The language layer’s own null hypothesis, and what six rounds said
Agents might do as well in an existing language with Mo’s checks bolted on. Rounds 1 to 6 of the control run tested the language layer on that question, with agent time and loops as the measure, and round 6 (the same job queue in Go with vet, staticcheck, and contracts, and in Python with mypy, ruff, and pydantic) found that no check in any language caught a bug the tests missed, and the baselines cost less to write. On that measure the null hypothesis stands. What those rounds did not test is the runtime and the capability layers, because logstat and a job queue exercise neither; from round 7 the measure is the one above, and program 7 is chosen to depend on capabilities, recipes, and the runtime surface. If a program built on those layers is no more reliable, no faster, and no leaner in dependencies than its Go or Erlang counterpart, that result changes the project. Its stopping rule is the third audit file above: unless never and invariant have caught at least two Mo defects no test would have caught by generation ten, at a false-positive rate of at most 1.5 times the catches and at most 5 per 1,000 lines, they leave the claim and stay in the language as tools (R-B).
Session 6 changes
- The thesis restated (Robert, 14 Sep 2026, on the outside review of the same day, and its reply that named the BEAM null hypothesis and the one-sentence thesis): the runtime, then capabilities and recipes, then the language as their surface; the counted shape laws become project settings; the control run’s measure is reliability, speed, the loop, and dependencies. The earlier premise, “agents do better with the compiler as teacher”, is kept as one hypothesis inside the third layer, with rounds 1 to 6 as its evidence so far.
Session 10 changes
- The stopping rules linked (Fable, 17 Sep 2026, on Robert’s installation of the auditor role the same day): the null hypothesis sections now point at the three ratified rules in
audit/; the thesis itself is unchanged.