ICM-OS: An Intent-Centric Meta-Operating System

— Abstract

Today's operating systems carry assumptions baked in decades ago: a binary exists for a specific ISA, an application ships as a self-contained package, and the distance between what a user wants and what actually runs is bridged by layers of static scaffolding no one questions anymore.

This paper describes the Intent-Centric Meta-Operating System (ICM-OS), a speculative but carefully grounded architecture in which an AI foundation model takes on the role of the OS abstraction layer. The AI is not a probabilistic replacement for the kernel—it is one half of a hybrid, responsible for semantic reasoning, intent decomposition, and emulation strategy, while formally verified primitives handle everything where determinism is non-negotiable.

ICM-OS is built around two mechanisms: the Capability Decomposition Model (CDM), which treats applications as dynamically assembled graphs of atomic capability primitives; and Generative Binary Translation (GBT), which replaces instruction-level ISA mapping with a semantic lift-and-synthesize pipeline.

1. Introduction

Each OS generation added a layer of abstraction: direct hardware access gave way to process and memory abstractions; physical hardware gave way to virtual machines; host environment assumptions gave way to containers. The pattern is consistent enough that asking what comes next feels less like speculation and more like reading the trend line.

What none of those transitions touched is a more fundamental assumption: software is a thing you compile, package, and install. TLS stacks are re-implemented in every major browser. ISA proliferation means a binary that runs on one machine may not run on another. The distance between what a user wants and the execution path that fulfills it is bridged entirely by developer effort expended at design time.

ICM-OS proposes a clean division of labor: the AI meta-system (AMS) handles semantic reasoning; formally verified, deterministic primitives handle execution. The AI decides what to run. Verified code runs it.

2. Related Work

2.1 Capability-Based and Microkernel OS

Capability-based OS designs [1, 2] introduced capabilities as access-control tokens. ICM-OS extends this: capabilities are semantic descriptors of computational function, composable by an AI orchestrator. ICM-OS is structurally closest to a microkernel—both move OS services out of ring 0 into user-space modules. The distinction is that microkernel composition is configured statically; ICM-OS performs it dynamically from intent at runtime.

2.2 Binary Translation

QEMU [7] faithfully replicates ISA semantics but incurs 2–10× overhead. Rosetta 2 [8] achieves near-native x86→ARM performance but required years of Apple engineering for exactly one ISA pair. GBT's key advantage is the elimination of the per-pair engineering cost—translation strategy derives from semantic understanding, not handwritten rules. The required engineering input is the target ISA specification; everything else follows from what the foundation model already knows about program semantics.

2.3 LLMs in Systems Contexts

AIOS [14] integrates LLM agents with conventional OS process management but treats the LLM as an application-level agent above a standard OS, not as the OS itself. ICM-OS is architecturally distinct: the AI is the abstraction layer, not a user of one.

3. Capability Decomposition Model

Consider what ships when you install a browser: a TLS stack, DNS resolver, HTTP client, HTML parser, CSS layout engine, JavaScript runtime, and dozens of other components. Chrome carries its own TLS implementation. Firefox carries its own. This is what the monolithic model structurally requires. CDM dissolves this coupling.

3.3 Stateful Primitives

A web-browsing session requires cookies, tokens, and cached resources that persist across multiple graph invocations. Three standard stateful primitives are defined:

[SESSION_STORE⟨K,V⟩]       — auth tokens, cookies, per-session prefs
[CACHE_LAYER⟨K,V,TTL⟩]     — TTL-bounded cache for idempotent resources
[FILE_STATE⟨path, schema⟩] — typed persistent file binding

3.4 Worked Example: Stateful Web Browsing

Intent I = "Log into example.com and bookmark the dashboard page."

// G₁ — Login
[DNS_RESOLVE] → [TCP_CONNECT] → [TLS_HANDSHAKE] → [HTTP_GET]
  → [HTML_PARSE] → [CSS_LAYOUT] → [JS_EXECUTE] → [WINDOW_RENDER]
  → [SESSION_STORE⟨cookie, token⟩]

// G₂ — Return to dashboard (session persisted)
[SESSION_STORE⟨cookie, token⟩] → [HTTP_GET(+auth)]
  → [HTML_PARSE] → [CSS_LAYOUT] → [WINDOW_RENDER]

No browser application was installed at any point.

4. Generative Binary Translation

Rosetta 2 represented years of engineering effort for exactly one ISA pair. As the hardware landscape fragments—ARM variants, RISC-V, WASM, proprietary NPU instruction sets—the cost scales as O(N×M). GBT offers generalization: the ability to handle a new ISA pair without writing new rules.

4.2 The Semantic Translation Model

// Traditional DBT — syntactic, table-driven
f: S_src → S_dst

// GBT — via semantic intermediate space
ℓ: B_src ──── Semantic Lifting ────→ M  (ISA-agnostic SIR)
s: M     ──── Semantic Synthesis ───→ B_dst (target-native)

GBT(B_src, S_dst) = s(ℓ(B_src), S_dst)

4.5 Applicability Boundary

Three classes fall outside GBT's current scope:

5. Case Studies

5.1 Stateful Text Reader via CDM

Intent I = "Open notes.txt and let me scroll through it and search for text."

[FILE_OPEN] → [FILE_READ] → [UTF8_DECODE] → [TEXT_LAYOUT]
          [SEARCH_INDEX] ↘ ↗
                    [WINDOW_RENDER] ↔ [SCROLL_INPUT]
                                         ↓
                              [FILE_STATE⟨preferences⟩]

[UTF8_DECODE] and [TEXT_LAYOUT] are the same verified modules used by the email client, document editor, and terminal—no re-implementation, no redundant bundling.

5.2 Cross-ISA Execution via GBT

An ARM64 binary uses NEON FMLA (fused multiply-add) SIMD instructions. GBT lifts the loop to SIR:

Σ(loop_body) = {
  description: 'vectorized fused multiply-add over float32 arrays',
  roles: { SIMD_ARITHMETIC, ALIGNED_LOAD, ALIGNED_STORE },
  pre:  'a, b, c are 32-byte-aligned float32 arrays of length n',
  post: 'result[i] = a[i] * b[i] + c[i] for all i < n',
  safety: safe
}

GBT synthesizes a loop using AVX-512 VFMADD231PS on x86-64—potentially achieving higher throughput than the ARM64 original because synthesis exploits target-native register width.

6. Comparison with Existing OS Paradigms

† ICM-OS: probabilistic AI composition + deterministic verified primitive execution.

7. Technical Challenges and Mitigations

7.1 Determinism

ICM-OS contains the probabilism-determinism tension through architectural separation. The AI reasons about semantics; verified primitives execute. Every graph produced by the AMS is type-checked, acyclicity-verified, resource-analyzed, and access-control-checked before execution. A probabilistically incorrect AMS output that fails validation is rejected; δ is reinvoked with the failure as a constraint.

7.2 Graph-Structure Attacks

Any path that lets an adversary influence AMS graph assembly might produce a graph that passes type-checking but behaves badly. The graph validator performs full static analysis including resource-bound analysis, cycle detection, and liveness analysis. The Confused Deputy problem is addressed by a graph-level policy engine that evaluates composite data flows against information-flow security policies (e.g., "data tagged sensitive may not flow to any network-output primitive").

7.3 Taint Tracking

Data entering through user-controlled external sources is tagged with a taint label at the primitive that ingests it. Taint propagates through the session-scoped dependency graph. The AMS intent channel is taint-isolated: tainted data may never be passed as input to the AMS's intent-parsing component.

7.4 Inference Latency

LLM inference latency is currently 10–1000× higher than kernel system call overhead. Three mitigations:

8. Research Roadmap

9. Conclusion

The assumption ICM-OS challenges is one the field has largely stopped questioning: that software has to be a pre-compiled artifact, installed on a specific machine, compiled for a specific ISA. The tools to pursue an alternative—foundation models capable of semantic reasoning, formal verification infrastructure for bounded software components—are now available or close enough to plan around.

ICM-OS is not a proposal to replace Linux. It is a proposal that the systems community has not yet asked the right questions about what an AI-first OS would actually require.

— References