Auto: AGI Compiler Framework

• Auto is a compiler system that transforms repeated LLM agent behavior into verified, persistent cognition binaries by recording and compiling deterministic execution spans.
• It utilizes a Rust-based pipeline with drop-in SDK shims, a typed task-graph IR, and both enumerative search and LLM-guided CEGIS for artifact synthesis.
• The system ensures execution fidelity through differential replay, calibrated runtime guards, and capability confinement via WebAssembly, with fallback to the reference agent when needed.

Searching arXiv for the specified paper and closely related work to ground the article in current literature. {"query":"(Jaber et al., 5 Jul 2026) Auto: The AGI Compiler", "max_results": 5} I’ll look up the paper entry and neighboring literature on arXiv before writing the article. to=arxiv_search тәшкиൻ{"query":"(Jaber et al., 5 Jul 2026)", "max_results": 10} Auto is a compiler-style system for transforming repeated large-language-model agent behavior into persistent executable artifacts. Introduced in “Auto: The AGI Compiler” (Jaber et al., 5 Jul 2026), it records live agent executions, identifies spans that are empirically stable enough to be treated as “witnessed-deterministic,” compiles those spans into WebAssembly-based “cognition binaries,” verifies them by differential replay against recorded behavior, and executes them behind calibrated guards that abstain to the original reference agent when novelty is detected. In the paper’s deliberately narrow usage, an “AGI compiler” is not a claim to artificial general intelligence, but a system that “autonomously converts novel experience into permanent, verified, near-free skill while measuring what it does not know” (Jaber et al., 5 Jul 2026).

1. Definition and operational scope

Auto frames the central deployment problem as the repeated re-derivation of already-stable agent behavior on expensive frontier models. Its target is not prompt optimization or model routing in the ordinary sense, but the extraction of reusable executable skill from traced agent runs. The unit of analysis is an effectful span, including model calls, tool calls, branch decisions, environment reads, and whole-task input/output; each span is recorded with latency and provider-reported cost (Jaber et al., 5 Jul 2026).

The core empirical notion is “witnessed determinism.” A span is witnessed when it has been observed at least twice, and it is deterministic iff all witnesses agree byte-for-byte and none errored. Auto reports fractions only over witnessed spans and does not extrapolate beyond them. This is important because the system’s guarantees are explicitly measured rather than universal. The distinction also underlies its use of parity: parity means agreement with recorded or reference behavior under a declared contract, not correctness with respect to external ground truth (Jaber et al., 5 Jul 2026).

A common misunderstanding is the interpretation of the phrase “AGI compiler.” The paper explicitly rejects a broad metaphysical reading. The claim is operational and testable: novel experience should be compiled into reusable, cheap skill, and the runtime should abstain when the input lies outside what has been measured. This makes Auto closer to a verified amortization system for agent behavior than to a general theory of intelligence (Jaber et al., 5 Jul 2026).

2. Compilation pipeline and intermediate representations

Auto is organized as a compiler pipeline implemented as a Rust workspace with 16 crates, 36,843 lines of Rust across 96 files, and 32 architecture decision records (Jaber et al., 5 Jul 2026). The front end uses drop-in SDK shims to trace live agent execution. Recorded traces are then lowered into a typed task-graph intermediate representation whose nodes carry capability effects, memory effects, resource bounds, and an uncertainty class:

$$\text{Deterministic} \mid \text{Probabilistic} \mid \text{Generative}.$$

The IR is byte-stable under serialization, which the paper treats as a property-tested invariant (Jaber et al., 5 Jul 2026).

Compilation proceeds along two main paths. For symbolic behavior, Auto performs extraction via enumerative search over a closed 17-operation DSL, and if that fails, via LLM-guided CEGIS. In that loop, a frontier model proposes candidate programs, while a sandboxed evaluator executes them on every witnessed input and returns counterexamples; the evaluator, not the proposer, is authoritative. For non-symbolic residue, Auto distills to small specialists such as decision trees or MLPs, with training able to use all witnessed outputs weighted by witness count rather than a single majority value (Jaber et al., 5 Jul 2026).

The emitted artifact is a “cognition binary,” represented as a signed, content-addressed .cbin containing WebAssembly code, possibly small models, and a manifest of measured properties and declared capabilities. This design turns compiled behavior into a portable execution object rather than a latent optimization inside an agent stack. The paper’s broader implication is that agent execution can be treated as a compilation target in much the same way that typed IRs and target artifacts mediate ordinary language-to-machine translation (Jaber et al., 5 Jul 2026).

3. Verification, contracts, and capability confinement

Verification is the acceptance criterion for artifact emission. Auto treats “verification, not synthesis” as the product. A candidate artifact must pass a declared contract by differential replay before it can be emitted. Contracts specify examples, properties, latency and cost budgets, and acceptance thresholds; the contract’s content hash becomes the artifact’s type (Jaber et al., 5 Jul 2026).

The gate uses three-valued verdicts: Pass, Fail, and Inconclusive. Any unmeasurable check is Inconclusive and is never upgraded to Pass; both Fail and Inconclusive block emission. Differential replay is taken as ground truth: every distinct recorded input is replayed through the candidate and compared against recorded reality. The default comparison is byte equality, though contracts may instead specify a statistical agreement threshold or, for generative spans, judged equivalence via an LLM judge. Manifest claims are restricted to measured numbers or null, and each parity claim carries the content-addressed identifier of the evaluation run that produced it (Jaber et al., 5 Jul 2026).

Capability declarations are not merely documentary. Auto uses WebAssembly as a physical enforcement boundary. A pure artifact has zero imports; the loader rejects modules whose imports exceed declared capabilities. A tool-using artifact imports exactly one host function, through which all tool invocations are mediated, named, audited, and budget-limited. This makes the manifest’s capability section enforceable by the sandbox rather than advisory metadata (Jaber et al., 5 Jul 2026).

This combination of contract-gated verification and import-level confinement is one of Auto’s main systems contributions. A plausible implication is that it redefines “cheap inference” as a typed and auditable runtime object, not simply a smaller model or a cache hit.

4. Tiered runtime, calibrated guards, and deoptimization

Auto executes compiled behavior in a two-tier runtime. Tier-1 runs the compiled artifact at near-zero marginal cost; Tier-0 is the original reference agent. Tier-1 execution is guarded by a conformally calibrated abstention mechanism. The guard computes lexical trigram sketches over witnessed inputs, measures similarity via Jaccard or hashed cosine, and sets the abstention threshold by split-conformal calibration over leave-one-out scores at a declared miscoverage level $\alpha$ (Jaber et al., 5 Jul 2026).

Operationally, compiled execution is allowed only when an artifact exists and the guard score is below its calibrated threshold:

$$A \neq \emptyset \;\land\; \mathrm{guard}_A(x) \le \tau_A.$$

Otherwise the runtime deoptimizes to the reference agent, serves the reference output, ingests the new trace, and after every $K$ new distinct inputs attempts recompilation. The paper’s ratchet loop uses $K=8$ in the stream experiment (Jaber et al., 5 Jul 2026).

The runtime slogan that “nothing is figured out twice” refers to this ratchet: novelty is paid for once at Tier-0, then compiled into the next artifact generation. The paper emphasizes, however, that the decisive engineering variables are not model capability but calibration and reference fidelity. If the guard is too loose, stale compiled behavior is silently served; if the deopt path does not reproduce the actual reference behavior, recompilation may be blocked by the verification gate (Jaber et al., 5 Jul 2026).

A technical limitation is that the current guards are lexical rather than semantic. The paper explicitly notes that misleading lexical cousins may be admitted while paraphrases with different vocabulary may abstain. This makes calibration a practical rather than purely formal problem.

5. Auto-Bench and empirical results

Auto-Bench is the paper’s pre-registered evaluation protocol, centered on four headline measurements: ratchet curve, determinism census, parity-gated compression, and calibrated ignorance (Jaber et al., 5 Jul 2026). Across four censused task families—ticket triage, a three-call inbox pipeline, typed field extraction, and policy routing—the benchmark records 560 witnessed frontier-agent spans, of which 87.1% are witnessed-deterministic. Three of the four families measure 100.0% witnessed determinism: F1 ticket triage, F3 field extraction, and F4 policy routing; the main exception is the inbox pipeline, whose summarization span is only 17.5% witnessed-deterministic (Jaber et al., 5 Jul 2026).

Compression results are highly task-dependent. F1 triage compiles from a frontier baseline of 55.6 micro-dollars and 904 ms to compiled cost \$0 and 65.7 ms, while F4 weighted routing compiles from 112.0 micro-dollars and 1037 ms to the same compiled cost and latency envelope. F2 classify passes 40/40 exact replay, whereas F2 priority fails because of three divergent-witness groups under an exact contract. F3 extraction refuses at all three rungs despite 100% determinism, because current compile rungs require outputs to be strings or DSL-expressible values. F5 summarization under judged equivalence fails at 17/40 = 42.5%, below the required 800‰ threshold (Jaber et al., 5 Jul 2026).

The stream experiment is the central closed-loop result. On a 300-item stream with three scheduled distribution shifts—adding security, then onboarding, then fraud phrasing—the runtime compiles three artifact generations and reduces total cost from 17,692 micro-dollars in the control to 2,775 micro-dollars, a 6.4× end-to-end reduction. Marginal cost falls from 59 to roughly 2 micro-dollars per item, Tier-1 serves 253 of 300 items, and parity on witnessed inputs reaches 96.9%, with zero execution errors reported in the ratchet run (Jaber et al., 5 Jul 2026).

The latency ladder further clarifies the runtime economics. Median frontier reference latency is 736 ms, whereas boundary overhead for a trivial compiled artifact is 21 ms over HTTP, 290 $\mu$s via a resident stdio process, 54.1 $\mu$s in-process through pyo3, and 18.2 $\mu$s in-process through napi (Jaber et al., 5 Jul 2026).

6. Failure modes, interpretation, and relation to other “Auto” systems

Auto’s most important negative result is that cheap execution does not remain correct automatically. In a loose-guard configuration (leg A, $\alpha = 0.100$ with a generic frontier deopt reference), the system serves 272 of 300 items in Tier-1 but silently produces wrong compiled answers on 48.9% of them. In a tighter configuration with the wrong deopt reference (leg B, $\alpha = 0.400$), silent wrongness falls to 28.4%, but recompilation is refused three times because the deopt examples do not match the contract’s target behavior. Only when the deopt path uses the actual agent itself (leg C, $\alpha$0) does the loop close, producing three successful recompiles and the reported 96.9% witnessed-input parity (Jaber et al., 5 Jul 2026).

The paper is equally explicit that parity is not semantic truth. In leg C, 53.8% of answers still differ from the six-label stream design because the reference agent itself operates with a three-label worldview. Auto preserves the reference behavior, including its blind spots. This makes semantic correctness and behavioral parity distinct notions (Jaber et al., 5 Jul 2026).

Within the broader arXiv landscape, Auto belongs to a family of systems that treat automation as a structured compilation or synthesis problem rather than as one-shot inference. AuTO formulates topology-optimization sensitivity analysis as differentiable program execution in JAX (Chandrasekhar et al., 2021); DiffTune treats controller tuning as gradient-based optimization over unrolled dynamics with sensitivity propagation (Cheng et al., 2022); AutoIoT combines LLM-based rule synthesis with formal verification and a code adapter for Maude (Cheng et al., 2024); Auto-Assembly converts CAD and process descriptions into executable robotic assembly plans (Zobov et al., 2023); and “Automated Algorithm Design for Auto-Tuning Optimizers” uses LLMs to synthesize optimizer code specialized to discrete constrained search spaces (Willemsen et al., 19 Oct 2025). This suggests that Auto’s distinctive move is not automation alone, but the packaging of repeated agent behavior into verified, sandboxed, executable artifacts with measured abstention.

In that sense, Auto is best understood as a compilation framework for amortized cognition. Its contribution is not a new frontier model, but a runtime discipline: measure which behaviors are stable, compile only what passes replay contracts, enforce capability boundaries physically, and pay the original inference cost only when novelty genuinely appears (Jaber et al., 5 Jul 2026).