“A new dialect is a small hiring pond.”
Regel's dialect is the largest developer pool and the deepest training corpus in software. There is nothing to learn — only things to subtract. Every model, and a million engineers, are fluent on day one.
Regel fuses two siblings. From kern: the application as governed, content-addressed rows in one Postgres — code that enters by admission transaction, pauses as continuations, and runs inside capability environments. From streng: the dialect — closed-world strict TypeScript 7, the most fluently machine-written language on earth, checked by a vendored native compiler in milliseconds. One Go kernel. One Postgres. Deploy is a commit. Rollback is a WHERE clause. And nothing lands unverified — not from an engineer, a tenant, or an agent.
Read side by side, kern and streng were converging and neither noticed. Kern conceded that nothing about code-as-rows requires s-expressions — only a canonical rendering and an AST with a schema. Streng's gate was already an embryonic admission pipeline; its sandbox was already kern's governed evaluation; its epoch was already kern's re-verify-the-world move. What kept them apart was that each carried a flaw the other had solved — confessed, in both documents, in their own honest edges:
Regel's dialect is the largest developer pool and the deepest training corpus in software. There is nothing to learn — only things to subtract. Every model, and a million engineers, are fluent on day one.
Regel puts tsgo — a real static checker, native and instant — inside the insert transaction. The type system kern had to rebuild from verifiers comes off the shelf; the verifiers are freed to check what types can't: capabilities, PII flow, contracts.
Regel stores the application as content-addressed rows: deploy is a commit, rollback is as-of, the artifact registry is the history tier, and the audit machinery finally covers the code. Git remains — as a deterministic projection, not as truth.
In regel, governed evaluation is the whole substrate. An engineer's deploy, a tenant's Settings edit, and an agent's patch pass one gate — the same transaction, the same verifiers, the same audit row. There is no privileged side door called “CI.”
Kern's shape, kept exactly. The kernel — a reactor, the vendored tsgo checker, an owned interpreter with a fuel meter, the verifier suite, and a wire protocol — is the only compiled artifact, and it ships zero business logic. It is to your product what Postgres is to your rows.
A patch arrives as TypeScript source. The canonical printer normalizes it to the one rendering; tsgo typechecks it against the catalog; the verifiers — capability audit, PII flow, contracts, catalog parity — run in the insert transaction, with the schema migration if it carries one. Rejected code never becomes code.
Admitted definitions run on the kernel's owned interpreter: the strict subset, CPS-transformed so any program can pause. Trusted code runs unmetered; tenant and agent code runs fuel-metered in capability environments — an unauthorized call isn't rejected, it's unnameable.
Workflows, UI sessions, and durable conditions are continuations — expression plus environment, stored with a wake condition. Any node resumes any of them, and a paused workflow resumes against the exact code hashes it started with. As-of for code deletes the workflow-versioning problem.
Every version of every row and every version of every definition, in one time-partitioned history tier. “Who changed this workflow, what did it look like, who approved it” is the same query as “who changed this record.” The SOC 2 answer is a SELECT, not a screenshot.
The canonical exchange: an agent submits a patch in the language it knows best, and the database answers — in the transaction — with a verdict. Everything on the left is plain strict TypeScript; everything on the right happens before the row exists.
import { workflow, days } from "std/taak"; import { sendIntro, sendContract } from "app/crm/mail"; export const followUp = workflow( async (wf, dealId: DealId) => { await wf.step(sendIntro(dealId)); await wf.sleep(days(3)); // continuation → row const ok = await wf.receive(Approval); if (ok) await wf.step(sendContract(dealId)); }, { capabilities: ["crm.read", "mail.send"] }, );
admit patch-3f9c by agent:builder-7 via mcp canonical print ✓ one rendering · 61 tokens tsgo 7 ✓ 0 errors · 91 ms capability-audit ✓ crm.read, mail.send — granted pii-flow ✓ no vault value escapes masked catalog-parity ✓ contracts ✓ → row 3f9c… catalogued · live · audit-rowed rollback: as-of — the previous app, forever rejected code never becomes code.
The same gate is the product's no-code surface: a tenant admin adding a field from
Settings submits an extendResource
form scoped to their org; a workflow drawn on the canvas lands as the same
workflow() definition an
engineer would write. And the framework ships its MCP server in the kernel: agents query
the catalog, fetch definitions by hash, submit patches, and receive verdicts as
structured data. The IDE is an API, and the API speaks TypeScript.
Kern planned to CPS-transform a Lisp designed for it. Regel must CPS-transform a strict TypeScript subset — async/await, closures, iterators — and serialize the environments stably across years. This is the deepest engineering bet in the family, owned, tested red-path-first, and built before anything else gets clever.
The owned interpreter is the tax; the envelope argument (I/O-bound SaaS, heavy lifting in SQL) carries v1, and the AOT lane — verified hot functions compiled to Go, taal's lane — is held in reserve, opened per-function when production says so.
Lisp gave kern restarts as a language feature. Regel engineers the same product truth: a failed step signals a durable condition row whose restarts render as buttons an operator presses. Equivalent behavior, less linguistic elegance — stated plainly.
TypeScript is not s-expressions. “Code is data” arrives through the subset's AST schema plus the canonical printer — one rendering, hashable, structurally diffable. That is enough for the catalog, the builders, and admission; it is not the full macro-expansion elegance kern had, and the derivation layer works harder for it.
The strict subset bans the lies it can see and derives runtime validators at every boundary, but structural-typing variance holes exist even in strict code. Verifier coverage is still the security boundary — versioned, adversarially tested, and stated as such. Kern's honesty, kept.
Regel inherits both build burdens: an owned engine and an admission substrate. The staging answer is ruthless: the walking skeleton is admit → row → evaluate → respond, end to end, before a single feature exists — and the deepest bets (printer, continuations, fuel) are proven under kill-tests before the world grows around them.
The pitch, in one sentence: your app, your schema, your workflows, your tenants' customizations, and your agents' patches are versioned TypeScript rows in one Postgres, evaluated by one kernel — deploying, auditing, and governing them is one mechanism, in the one language every model on earth already speaks.
Between 2026-07-09 and 2026-07-18 this stopped being a concept study. One Go kernel, one real PostgreSQL 16.13, an operator go/no-go gate between every stage, an external twelve-expert review, a fresh-eyes re-verification, and a final residue burn-down that turned twelve open items into machinery — across 20 session strands. Every claim below traces to a red-path test, a runnable demo, or a named residue. Nothing is silent — and when it was done, a council of reviewers was turned loose to find where the prose outruns the proof.
One binary + Postgres: the full admission pipeline, the owned CEK interpreter at 27.1M steps/sec (27× the floor, metering tax ≈0%), and the admit/rollback/as-of demo — before a single feature existed.
A workflow killed mid-step resumes on a different kernel to the identical result, effects exactly-once. A year-old continuation — under a backdated clock — resumed across an epoch. A 10k wake storm, zero duplicates. Resume p95 ~58ms; a serialized environment is ~199 bytes.
V1–V6 red-pathed with a hostile fixture corpus; 13 seeded production mutants all caught. Real tsgo typechecks inside the insert transaction at p95 = 12ms. The MCP agent plane (11 tools) and the byte-identical git projection walk the same gate.
Two fresh databases produce byte-identical worlds. The reactive layer ships server-rendered templates with binary SSE deltas — 50k-session storm drained exactly-once in 34s, optimistic echo at 0.0ms perceived latency.
Three erf resources, a workflow, a component, a typed SQL read — zero app logic in Go, grep-proven. Five scenarios scripted and passing: tenant field-add, agent patch over MCP, a workflow surviving two deploys mid-flight, rollback observed through the UI, vault crypto-shred with a clean history.
Authoring: pass@1 = pass@3 = 1.00 on a 52-task suite — pure-computation tasks, the model handed the dialect rules (k pinned per epoch; the retry ceiling is not a dial). Restart decisions: 0.968 accuracy on 31 labeled scenarios — so the agent's restart authority flipped on through its mechanized gate. It proves the governed plane works end to end; the harder corpus of real resources is v2's to run.
An agent restarted a real parked workflow across the flipped authority; the epoch migrate ran a genuinely new std pair; the settings form, operator-plane live updates, as-of row data, and two std batteries all landed as admitted rows. Chasing them red-path-first surfaced three real defects — a SELECT that could write, a migrate keyed on the wrong column, a template throw that leaked PII — each fixed with the failure witnessed first.
The discipline held under embarrassment, which is the real test. The first eval run's numbers were harness artifacts — kept as evidence, fixed red-path-first, re-run. An outside reviewer's first verdict on the reference CRM was UNFINISHED — the specifics were fixed and the re-review recorded as rows. Two bugs were found only by using the system, both fixed with the failure witnessed red first.
A systems architect, a security engineer, a database expert, a product lead, and a designated skeptic each read the specs against the code — not the narrative. Their brief was to find what strains, what is over-claimed, and what breaks. None of them called it a paper architecture; the mechanisms, they agreed, are real engineering that matches its ADRs. All of them found the same fault line: the deepest, most-repeated claims are provisioned but unexercised, and the vision is more confident than the evidence beneath it.
The CEK machine, the hand-rolled Postgres wire client, and the content-addressing are real and match the ADRs. But everything lives at format version 1 — the decoders reject any other — and the "year-old resume across an epoch" test advances the epoch by copying identical manifest roots. "Resume for years across epochs" is a design, not yet a result. And the one Postgres has no failover, replication, or restore drill specified: forever is currently one un-replicated disk.
Vault plaintext really is unreachable, the SELECT-only fix is engine-enforced, the restart flip fails closed. But typed SQL reads carry no injected tenant predicate and there is no row-level security anywhere — cross-tenant isolation rests on the app author remembering a WHERE clause the reference app itself omits. No statement timeout, and an advisory lock can poison a pooled connection. Harden per-tenant row isolation before a second tenant.
Corruption is made unrepresentable rather than policed, and the git fold is genuinely determinism-safe. But a single global admission id underwrites the fold, the projection, and every as-of query — so the substrate cannot shard, and the history, outbox, and continuation tables grow forever with no aging path. The as-of reconstruction can even surface a row created after the queried instant. Decide now, in writing: is v1 one Postgres, one region, by design?
A 170-line CRM derives tables, history, policy, forms, REST, MCP tools, and a live UI; durable workflows take no ceremony; PII is a type modifier. Real, differentiated leverage. But the UI renders from a closed vocabulary with no charts, no custom widgets, no third-party embed and no escape hatch — a real product team hits that wall in week two and can only wait for a new kernel epoch. The proof CRM validates the substrate, not yet a product.
Exactly-once across a real kill -9 is a database fact; red-path-first is not theater; zero-business-logic-in-Go holds literally. But pass@1 = 1.00 was scored on toy arithmetic — gcd, fizzbuzz — in a dialect the eval configures to forbid the imports, types, and calls that make regel regel, with the decision rubric handed to the model in the prompt. It proves the governed plane works; not that an agent can author a real resource. The storms are cloned rows; the stranger review is Claude judging Claude.
Two reviewers converged on it independently. What is proven is that the mechanisms are correct at version 1, one node, small N, simulated time. What is asserted more confidently than shown is that they hold for years, across format versions, at scale, under a real agent workload. The risk register already says most of this — the honest fix is to make the vision speak in the same voice as its own risks.