Structure is derived, never designed. It survives only while it stays green.

MeG4 is a universal agentic harness — an engine that turns natural-language intent into verified work. Its single invariant: every structure the system produces or contains is derived from intent expressed in plain English, and is allowed to exist only while it passes an executable falsifier. This document explains the machinery behind that sentence: contracts, the layered architecture, the tiered model economy, roles as swappable adapters, the verification stack, and the loop by which the system improves itself under the same rules it imposes on its output.

The thesis

Modern AI coding assistants compete on the model. MeG4's bet is that the durable advantage lives one level up, in the harness — the system that decides what the model is asked, how its work is checked, when a cheaper model suffices, and what happens when it fails. Recent literature has converged on the same conclusion: harness design decisions, not model choice, dominate end-to-end outcomes [1] [4].

The thesis has three commitments:

• Falsification over trust. No output, no plan, no self-modification is accepted on plausibility. Everything is judged by an executable check that was written before the work and proven capable of failing.
• Natural language is the only human layer. Humans express intent in English; the system derives and refines its own substrate (configs, prompts, structures, even proposals about itself) below that line.
• Personal and local. The harness runs on hardware the owner controls, with open models, and it specializes per user and per role — it is a private engine, not a shared cloud service.

The contract: specs with teeth

The unit of truth in MeG4 is the contract: a markdown note with structured frontmatter that couples a human-readable intent to one or more executable acceptance checks — the falsifier. A spec without a falsifier is decoration; it gets violated silently. A contract cannot be.

Three disciplines make contracts trustworthy rather than theatrical:

• Proven winnable, proven losable. Before a falsifier is accepted, it must pass against a known-good reference and fail against a known-broken mutation. A check that cannot go red is not a check.
• Author ≠ arbiter. The agent that writes the falsifier must not be the agent that satisfies it — independence is recorded in the contract's ledger and audited.
• Out-of-band gating. The gate runs outside the model's control loop. The model cannot mark its own homework.

Agents communicate through the same discipline. Any tier, at any step, emits exactly one of three words — the trit:

The trit is a sum type enforced at compile time and constrained at decode time. It removes the ambiguity that lets agent systems drift: every hand-off is either a verdict or a falsifiable promise.

Architecture: five layers, one direction of dependency

Two properties matter more than the layer count:

• The core is pure and model-agnostic. L0 contains the algebra of the system — contracts, verdicts, routing — with no I/O and no model names. A CI gate fails the build if impurity leaks in. Swapping every model in the system is a one-word config change (the backends: map), not a refactor.
• Autonomy is bounded by contract, not by trust. The field is actively debating how much structure agent collectives need — recent work shows self-organizing agents can beat designed hierarchies at the frontier, while models below a capability threshold still benefit from imposed structure [7]. MeG4 runs local, mid-scale models and sells accountability, so it takes the conservative side of that trade: the planner emits a contract; everything downstream is free within it.

The three-tier engine: intelligence where it pays

One model doing everything is the most expensive possible design. MeG4 splits every job across three seats, each holding only what it needs:

The economics follow from the separation: the expensive model reads little and writes less; the model that reads everything is cheap; the model that does the labor is local and effectively free at the margin. Measured on external benchmarks against a frontier model doing the whole job alone, the orchestrated stack lands in the same quality band at roughly an order of magnitude lower cost — and the honest claim is cost-optimal orchestration, never "a better model."

Roles as hot-swappable LoRAs

A role in MeG4 — planner, worker, judge, analyst, and eventually Support, Sales, Ops — is not a hard-coded agent. It is:

• a stable name, addressable in config;
• a versioned prompt-spec — the role's charter, rules, and evidence standards, kept in the repo like any other contract;
• an adapter seat: every tier can mount a LoRA (adapter: / adapters:) on top of the shared base model, hot-swappable per request.

The consequence: "many agents" does not mean many models. One base model on one GPU serves dozens of role personalities, each a lightweight adapter trained from that role's own gate-verified history. Today's prompt-spec is tomorrow's LoRA training set — the role is specified in language first, then distilled into weights once its ledger holds enough verified examples. Distilling a prompted persona into weights is established technique (context distillation, prompt baking), and per-role training runs have been exercised on our own cluster — this path is engineering, not research.

This is also the personalization story: a company's MeG4 Support learns that company's tone and playbook as an adapter — private, swappable, and owned by the customer.

The verification stack: three gates and a vetted inventory

Feeding the gates is the vetted stack registry: one pinned technology stack per use case (SSR web, SEO web, full-stack business, Rust service, CLI, script, ML/Python…), each entry carrying its own L2 check and QA recipe. The planner chooses a key, the scaffold delivers a known-good starting point, and the worker composes rather than invents. This mirrors how the strongest commercial generators win — pinned, opinionated stacks [3] — while the falsifier stays stack-agnostic: it measures outcomes, not technology choices.

Memory: the contract graph is the knowledge graph

Contracts are markdown notes with wiki-links, so the portfolio is a typed graph: epics link to contracts, contracts to their falsifiers and ledger events, roles to their prompt-specs. The same graph renders in the console, on the web, and feeds retrieval — institutional memory is not a side database, it is the working substrate itself, in a format both humans and agents read natively. Long-term archive lives in a local RAG; the direction of travel is one unified graph where a link is a link everywhere.

Sovereign inference: our models, our metal

• Own hardware. The engine's labor runs on a private GPU cluster (Blackwell-class, unified-memory workstations) — the brain orchestrates from a separate always-on machine. No per-token dependency on any AI vendor for the core work.
• Native model-access layer. Routing, health, and failover are MeG4 code, not a third-party proxy: every seat declares primary and fallback backends across providers, so the system is never out of fuel — it degrades deliberately, and if everything is dry it stops with an honest model_error rather than silently benchmarking garbage.
• Deployment symmetry. The same binary and config grammar runs hosted on our hardware or on-premise in a customer's office — privacy as a deployment choice, not a product tier.

The self-building loop — under its own rules

L2 closes the loop: the system mines its own failure ledger, proposes changes to its own configuration and prompts, and validates each candidate on a frozen held-out set it never trains against. Promotion requires paired statistical significance (McNemar over per-task outcomes), not vibes; efficiency regressions veto.

Where does this stand? Honestly: the machinery is built and gated; the improvement slope is not yet demonstrated above noise. Our own audit found the early loop was flat by construction (a memoryless proposal generator), found a "credible win" announcement that failed its own falsifier, and found masked checks in the portfolio — and the system's response was to file each finding as a red contract and repair the falsification substrate first. Independent 2026 results show a harness improving itself by 14–21 points of held-out pass rate (e.g. 40.5%→61.9% on Terminal-Bench 2.0) with no stronger model, using exactly this mining→proposal→held-out-validation shape [2] — the loop is the right bet; our differentiator is that we refuse to claim it before our own gate goes green.

Relation to the field

Each pillar of MeG4 now has independent validation in the 2026 literature — the combination is what nobody else ships:

1. [1] arXiv:2604.25850 — Agent-Harness Engineering: falsifiable contracts + ledger + held-out validation; harness > model. Validates the core thesis.
2. [2] arXiv:2606.09498 — Self-Harness: harnesses that improve themselves (weakness mining → proposals → regression-tested validation); +14–21pp held-out on Terminal-Bench 2.0 across three models. Validates L2's shape.
3. [3] arXiv:2604.03515 — Source-code taxonomy of 13 coding-agent scaffolds; convergence where constraints dominate. Grounds the pinned-stack registry and scaffold design.
4. [4] arXiv:2604.18071 — Architectural design decisions in AI agent harnesses. Harness decisions dominate outcomes.
5. [5] SpecOps @ SPLASH/ISSTA 2026 — specifications as living, executable, lifecycle-spanning artifacts. The contract, arrived at independently.
6. [6] arXiv:2605.01160 — Specification-driven governance for AI-augmented development. Spec-as-source-of-truth, industrialized.
7. [7] arXiv:2603.28990 — Drop the Hierarchy and Roles: self-organizing agents outperform designed structures at the frontier; models below a capability threshold still benefit from imposed structure. We take the conservative side for local models + accountability.

What remains uniquely ours: the trit hand-off discipline, proven-losable falsifiers with author-independence applied to the harness itself, roles as hot-swappable per-user adapters over one local base model, and the equal-model invariant as a reporting standard — one engine carrying all four, running on hardware we own.

Status & direction

The direction is unchanged since the first line of the core: an engine that staffs companies with verified, personalized, locally-run agent roles — and that improves itself under the same contract it applies to everything it ships.