{"id":"978abd78-c49e-4fd2-930a-7862280e0d4f","arxiv_id":"2607.25076","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Agentic systems need an Agent-OS of thirteen OS/Cloud-OS-derived primitives with precise platform-enforceable semantics before portable production adoption is possible.","lead":"The paper argues agentic AI is stuck in a pre-POSIX experimentation phase and needs a shared Agent-OS: thirteen platform primitives extended from classical and cloud OS ideas. If the field agreed on those semantics, multi-vendor agents could become portable, auditable, and operable like Kubernetes workloads.","discovery_kind":"extension","skeptic_critique":{"model":"moonshotai/kimi-k3","headline":"The \"follow the prior-wave methodology\" prescription inverts the causal order of its own exemplars: POSIX and Kubernetes ratified dominant implementations rather than preceding consolidation, so the specification-first path is not the lesson the history actually teaches.","rationale":"The reader's weakest assumption asked whether the POSIX/Kubernetes playbook transfers to stochastic, NL-mediated, self-concealing workloads — i.e., whether enforceable semantics can be specified at all for the intrinsic gaps. That is a real concern and the paper itself concedes it (Table I marks five-plus primitives \"Open/Long — requires new formal theory with no direct prior-wave precedent\"). My concern is adjacent but distinct: even setting aside whether the semantics are specifiable, the historical methodology the paper invokes is misdescribed — both exemplars consolidated around winning implementations rather than following an articulation-first path. This matters because the paper's prescriptive payload (\"the path forward is to follow the prior-wave methodology\") depends on the accuracy of that description. I do not recommend changing the verdict: this is a position paper, it hedges its taxonomy appropriately, it ships a prototype (rossoctl) demonstrating implementability of the \"Partial/Near\" primitives, and its taxonomy has value independent of the historical framing. CONDITIONAL with the reader's stated conditions remains the right call; the revision I would ask for is a softening or correction of the causal-historical claim in §II-A and Lesson 1, plus reframing the primitives as candidates to be validated by implementation competition rather than a specification-first precondition.","tokens_in":18126,"tokens_out":3614,"duration_ms":100616,"concrete_test":"Verify the causal ordering for both exemplars. (1) POSIX: document whether cross-vendor Unix portability (C portability, common syscall surface across v7/BSD/System V) substantially predated IEEE 1003.1-1988 and whether the standard primarily ratified existing practice. (2) Kubernetes: document whether its semantic model was fixed by implementation dominance (post-2015 adoption vs. Mesos/Swarm) before any standardization process. If both confirm implementation-first, the paper should reframe its prescription accordingly. Supplementary forward check: attempt a precise, platform-enforceable semantics for one \"Open/Long\" primitive in Table I (e.g., failure detection under self-concealment, §IV-J); if even one resists specification, the achievability premise of the strongest claim weakens independently of the historical issue.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The strongest claim has two parts: (1) consensus on abstractions with platform-enforceable guarantees is necessary for the field to advance beyond prototypes; (2) the path is to derive primitives from prior layers, specify semantics precisely, and then consolidate — \"just as POSIX and Kubernetes consolidated their respective waves\" (Abstract; §I; §II-A; Lesson 1, §VI). Part (2) rests on the three-phase arc in which articulation precedes consolidation. The historical record runs the other way. POSIX (IEEE 1003.1-1988) codified an already-dominant Unix practice after years of de facto cross-vendor portability via C and the v7/BSD/System V source culture; it ratified a winner rather than creating portability. Kubernetes won an orchestration market contest (Mesos, Swarm, Nomad) with a concrete Borg-descended implementation; its pod/reconciliation semantics became standard because the implementation dominated, not because the community first agreed on semantics and then built platforms. If consolidation-through-implementation is the actual mechanism, the paper's prescription — specify semantics for thirteen primitives first — is not \"the same methodology the prior eras used,\" and the necessity direction of part (1) also weakens: both prior eras ran large production systems on pre-standard, bespoke infrastructure for years, and the paper's own citation [63] (95% of enterprise GenAI deployments fail) implies 5% succeed without an Agent-OS. This does not invalidate the taxonomy — it remains a useful Phase-2 vocabulary, and the paper hedges correctly (\"not claimed to be complete or minimal,\" §IV) — but it undercuts the historical-necessity argument that carries the paper's central rhetorical weight. The honest reframing is that the thirteen primitives are hypotheses to be validated by competing implementations, not a precondition for progress.","agreement_with_reader":"partial"},"referee_report":{"model":"moonshotai/kimi-k3","summary":"This is a position paper arguing that agentic AI is in the \"pre-POSIX\" experimentation phase of a third platform wave, and that the field should follow the methodology of the classical-OS and cloud-OS eras: articulate a small set of stable abstractions with precise, platform-enforceable semantics, then consolidate. The paper (i) presents a three-phase historical arc (experimentation → articulation → consolidation) anchored on POSIX and Kubernetes; (ii) gives a semantic-gap analysis (§III) distinguishing structural breaks (external-world action, irreversibility, dynamic authorization) from stochasticity-intrinsic breaks (no WCET, no replay, no temporal locality, self-concealment); (iii) derives thirteen \"Agent-OS primitives\" (Table I) via a stated three-question method, each with OS and Cloud-OS origins and an open specification problem; (iv) describes rossoctl, an open-source Kubernetes-based prototype implementing a subset; and (v) closes with four \"lessons\" and an eight-item research agenda.","tokens_in":18494,"tokens_out":3096,"duration_ms":165541,"significance":"If the framing is repaired, the durable contributions are real: the §III split between structural gaps (which have classical precedents — compensating transactions, capability security) and stochasticity-intrinsic gaps (which do not) is a genuinely useful analytic distinction that disciplines what needs new theory versus engineering extension; Table I is a well-organized consolidation artifact mapping each primitive to its gap, status, and horizon; and the eight open problems in §VII are concrete and mostly falsifiable (e.g., \"bound the cost of eviction errors in terms of downstream task failure\" in §IV-E). The three-question derivation method is stated explicitly and the taxonomy is honestly disclaimed as neither complete nor minimal. The gap analysis is well-sourced on failure modes, self-concealment, and supply-chain statistics. These strengths survive the framing problems below, which is why I do not recommend rejection.","major_comments":[{"comment":"The three-phase arc is historically inverted for both exemplars, and this is load-bearing because Lesson 1 ('standardization is the exit from experimentation') and the Abstract's prescription ('specify their semantics precisely, and consolidate around them — just as POSIX and Kubernetes consolidated their respective waves') rest on it. POSIX (IEEE 1003.1-1988) codified an already-dominant Unix practice after years of de facto portability via C and the v7/BSD/System V source culture; it ratified a winner. Kubernetes won an implementation contest against Mesos/Swarm/Nomad with a concrete Borg-descended system; its pod/reconciliation semantics became standard because the implementation dominated, not because the community agreed on semantics first. The paper's Phase-2-before-Phase-3 ordering is therefore not 'the same methodology the prior eras used.' This does not invalidate the taxonomy,","section":"§II.A and §VI, Lesson 1"},{"comment":"The thirteen 'primitives' are heterogeneous in kind, and several entries contradict the paper's own definition of a primitive as a platform-enforced abstraction with specified semantics. §IV-B's Agent-OS primitive for orchestration is literally 'CrewAI, LangGraph, AutoGen ... extended with token-budget quotas, semantic loop detection' — i.e., the Phase-1 frameworks the paper elsewhere criticizes as non-composable, plus unbuilt features. §IV-K's observability primitive is a list of products (LangFlow, Arize, MLFlow). §IV-M's is 'alternative lightweight implementations (Rust-based) emerge.' In contrast, §IV-D (tool mediation with a reversibility model) and §IV-E (context management with a stated open theory) do describe abstractions with semantic content. The paper should either re-specify the weak entries at the same level of abstraction as the strong ones (what guarantee, enforced where,","section":"§IV, esp. §IV-B, §IV-K, §IV-M"},{"comment":"The empirical urgency claim rests almost entirely on [63] (MIT NANDA, '95% of enterprise GenAI deployments fail'). That report's methodology (52 interviews, self-reported outcomes, non-standard definition of 'failure' as no measurable P&L impact within six months) has been widely contested, and the 95% figure is doing real work in the Conclusion ('the answer is not more frameworks'). The inference is also weaker than stated: the report attributes failure to brittle workflows and integration gaps, which is consistent with, but does not establish, the need for standardized platform semantics rather than, say, better engineering practice. The claim should be qualified (e.g., 'attributed by one industry study') and ideally corroborated with the production-deployment evidence the paper already cites ([11]).","section":"§VIII and [63]"},{"comment":"The rossoctl section is presented as 'demonstrating that the primitives are implementable within the existing Cloud-OS substrate,' but it contains no evaluation at all — no description of workloads run, policies enforced, overhead measured, or even which of the thirteen primitives are implemented versus planned. For a position paper a full evaluation is not required, but the implementability claim should be scoped honestly: a sentence stating which primitives rossoctl currently enforces (identity attestation and MCP-gateway authorization, per Figure 2, appear to be the real ones) and which remain unimplemented would convert an assertion into evidence. Table I's 'Partial' status column presumably encodes this, but the mapping is never made explicit.","section":"§V"}],"minor_comments":[{"comment":"Reference [27] is cited for 'MCP standardizes via schema-documented server wrappers,' but [27] is an IBM tech report on the Kagenti/Kuadrant MCP gateway, not the MCP specification. Cite the actual MCP spec (Anthropic/modelcontextprotocol) for the protocol claim.","section":"§IV-D and [27]"},{"comment":"The Status (Open/Partial/Early) and Horizon (Near/Mid/Long) columns are assigned with no stated methodology. A one-paragraph rationale (what distinguishes 'Partial' from 'Early'; what evidence places context management at 'Long' but tool mediation at 'Mid') would make the table's most decision-relevant content defensible.","section":"Table I"},{"comment":"'uTCP' is used repeatedly without citation or definition on first use. Also, the claim that 'MCP/uTCP/A2A evolve faster than Envoy release cycles' is asserted without support.","section":"§IV-D, §IV-M"},{"comment":"Heading typo: 'Agent as an first-class entity' → 'a first-class entity.' The same subsection introduces 'context-assemble → infer → tool-call → update' as the agent lifecycle, which differs in terminology from the §II.2 loop (perception/planning/action); unify.","section":"§IV-A"},{"comment":"Several typesetting artifacts suggest missing italics commands: 'theclassical server era,' 'thecloud era,' 'PersistentV olumes,' 'agentic erais,' 'evaluateable' (§VII.6). Figure 2's caption has an unbalanced parenthesis ('run above the platform layer').","section":"§I, §VI"},{"comment":"Reference [4] cites a conference keynote with a timestamp for the 'LLM-OS framing'; Karpathy's later written articulation (or [62], already cited) would be a more stable source. Reference [62] is described as a 'blog post' — give a URL. Several arXiv citations ([5], [7], [8], [10], [17]–[21], [28]–[32]) are 2026 preprints; a sentence noting which are peer-reviewed would help readers weight the evidence.","section":"§I and references"},{"comment":"The claim that 'an agent written for LangGraph does not run on CrewAI' is true of framework internals but should acknowledge emerging portability layers the paper itself cites (A2A, MCP) more precisely — the portability gap is at the platform-guarantee level, not the wire level, and saying so would sharpen rather than weaken the argument.","section":"§II.A"}],"recommendation":"major_revision","confidential_remarks":"Both authors are at IBM Research, and three of the systems presented as evidence or primitives ([27] MCP gateway, [51] Praxis, [53] rossoctl) are IBM projects; this is disclosed by affiliation and is common for position papers, but the editor may want to ensure the 'open-source prototypes' section is not read as neutral survey. The manuscript acknowledges AI assistance in drafting (Claude Sonnet 4.6), which is appropriately disclosed. The core taxonomy and gap analysis are publishable; the requested revision is substantial (reframing the historical argument and tightening Table I) but does not require new research, so I expect it is achievable in one round."},"author_rebuttal":null,"desk_editor":{"model":"grok-4.5","letter":"The useful core here is not a new theorem or measured system. It is a clean systems-position packaging: where classical OS and Cloud-OS guarantees actually break for stochastic, tool-using, externally acting agents, and a thirteen-primitive taxonomy with status/horizon labels plus an explicit open research agenda.\n\nWhat is new relative to Karpathy, AIOS, MemGPT, and the memory/resource papers is breadth and method. They walk process→pod→agent, scheduler→token/loop quotas, syscall/mesh→tool mediation, VM→context, FS→semantic memory, RBAC→runtime-context AuthZ, probes→self-concealment, etc., with a repeated three-question derivation and a table that separates Near/Mid/Long work. The semantic-gap section is the strongest part: external irreversible actions, non-replayability, meaning-dependent eviction, strategic misreporting, and NL policy undecidability are real, and they cite the right failure-mode and supply-chain literature. rossoctl as a K8s-native partial prototype is honest about scope (cloud/datacenter, not edge) and correctly treats the Agent-OS as a layer on Cloud-OS rather than a replacement.\n\nSoft spots, in proportion. The load-bearing historical claim is soft. POSIX largely ratified dominant Unix practice; Kubernetes won an implementation contest, then its semantics stuck. The paper’s “articulate semantics first, then consolidate—just as POSIX and K8s did” inverts that order. That weakens the necessity rhetoric (“cannot advance beyond prototypes without consensus”) more than it weakens the taxonomy: both prior eras ran serious production on pre-standard stacks, and their own 95%-fail citation implies some deployments already work without an Agent-OS. Several primitives remain wish-lists (token-relevance theory, decidable NL guardrails, stochastic scheduling); the paper mostly admits this in §VII, so it is incompleteness, not sleight of hand. No new empirical validation of the full set—expected for a position paper, but the portability claim outruns evidence.\n\nWho it is for: people building agent runtimes, gateways, and enterprise control planes who need a shared vocabulary and a research punch list. Citation pattern is appropriate; argument is coherent on its own terms.\n\nI would bring it to reading group as agenda-setting systems writing, cite the gap table when framing platform work, and send it to peer review. Referees should force a softer historical claim and sharper “hypotheses for competing implementations” framing, not desk-reject it.","headline":"Useful Phase-2 taxonomy of agent platform gaps; the POSIX/K8s “specify then consolidate” history is oversold, but the primitive set and open agenda still deserve referee time.","tokens_in":19509,"tokens_out":614,"would_cite":true,"duration_ms":15027,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.5","headline":"Agentic AI needs an operating system: stable, portable abstractions extended from classical and cloud OS primitives, not more frameworks.","keywords":["agent operating system","LLM agents","platform abstractions","POSIX","Kubernetes","semantic gap","tool mediation","context management"],"falsifier":"If, after serious attempts to specify and implement the proposed primitives (especially context eviction, natural-language guardrails, and failure detection under self-concealment), independent platforms still cannot offer portable guarantees and production agent systems remain framework-tied or best-effort, the consolidation claim fails.","tokens_in":19290,"feed_emoji":"⚙️","tokens_out":902,"duration_ms":34835,"temperature":0.7,"pith_summary":"The paper argues that autonomous LLM agents are in the same early, fragmented phase that classical operating systems and cloud platforms once occupied—lots of competing frameworks, no agreed platform guarantees. Without a small set of stable abstractions with precise semantics, agent applications cannot be portable, platforms cannot compose across vendors, and production systems stay bespoke. The authors claim the way out is the same path POSIX and Kubernetes took: extend proven OS and cloud primitives to handle stochastic, natural-language-mediated, externally acting agents, specify what the platform must enforce, and consolidate around those guarantees. They propose thirteen such primitives—from agent lifecycle and tool mediation to context management, guardrails, and trajectory observability—and show that a subset can already be implemented on Kubernetes rather than replacing it. A sympathetic reader cares because enterprise agent deployments are already failing on reliability, governance, and integration; the paper says those are infrastructure problems, not model problems.","feed_headline":"Agentic AI needs an OS, not more frameworks","feed_subtitle":"Extend POSIX and Kubernetes primitives to stochastic agents, then standardize the guarantees","key_machinery":"Semantic-gap derivation of thirteen Agent-OS primitives: for each classical or cloud OS abstraction, ask what guarantee it gave, whether that guarantee holds for agents, and what must change for stochastic, natural-language, real-world action—then treat only the genuine gaps as new platform work.","core_discovery":"Agentic systems will not mature past prototypes until the field articulates and standardizes an Agent-OS: a platform layer that extends classical OS and Cloud-OS abstractions to stochastic, natural-language-mediated, externally acting agents, specifies enforceable semantics for those abstractions, and consolidates so applications can target them portably—exactly as POSIX and Kubernetes did for prior waves.","pith_inferences":["If self-concealment and open failure spaces resist decidable detection, Agent-OS may need mandatory human-in-the-loop and risk-tiered enforcement as permanent architecture, not temporary scaffolding.","The same three-phase arc argument predicts that MCP-style communication standards alone will not yield production reliability until execution guarantees (authorization, reversibility, observability) are specified beside them.","Success of the thirteen-primitive taxonomy would pressure cloud vendors to compete on Agent-OS conformance the way they compete on Kubernetes distributions today."],"forward_implications":["Portable agent applications become possible only after agreed semantics for lifecycle, tools, memory, auth, and observability—not after more agent frameworks.","Reliability, safety, and cost bounds for agents must be enforced by infrastructure (schedulers, mediation, immutable audit), not by prompts or model self-checks.","Agent-OS should extend Kubernetes and related cloud primitives rather than replace them; multi-cloud and on-prem operation stay first-class.","Open specification work concentrates on genuine gaps: stochastic scheduling, semantic skill contracts, NL policy languages, principled context eviction, and agent-aware failure recovery.","Frameworks that ignore platform-enforceable guarantees will keep being discarded when systems move from prototype to production."],"fun_headline_variants":["Agentic AI needs shared OS abstractions, not more frameworks","Extend POSIX and Kubernetes primitives to stochastic agents","Without an Agent-OS, agent apps stay non-portable prototypes","Standardize agent abstractions the way POSIX and Kubernetes did","Agent platforms must consolidate on enforceable OS-like semantics"],"cache_read_input_tokens":16512,"weakest_assumption_plain":"That useful, portable, platform-enforceable semantics can actually be written for intrinsically stochastic agents with open-ended natural-language goals and strategic self-concealment, the way POSIX and Kubernetes semantics were written for deterministic programs and services.","fun_headline_variants_meta":{"raw":{"variants":["Agentic AI needs shared OS abstractions, not more frameworks","Extend POSIX and Kubernetes primitives to stochastic agents","Without an Agent-OS, agent apps stay non-portable prototypes","Standardize agent abstractions the way POSIX and Kubernetes did","Agent platforms must consolidate on enforceable OS-like semantics"]},"model":"grok-4.5","effort":"low","cost_usd":0.0024,"raw_usage":{"total_tokens":923,"prompt_tokens":730,"num_sources_used":0,"completion_tokens":80,"cost_in_usd_ticks":24004000,"prompt_tokens_details":{"text_tokens":730,"audio_tokens":0,"image_tokens":0,"cached_tokens":128},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":113,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":730,"tokens_out":80,"duration_ms":3424,"temperature":1.0,"reasoning_tokens":113,"cache_read_input_tokens":128,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-31T01:56:33.906672+00:00","model_set":{"reader":"grok-4.5"},"falsifier":"If, after serious attempts to specify and implement the proposed primitives (especially context eviction, natural-language guardrails, and failure detection under self-concealment), independent platforms still cannot offer portable guarantees and production agent systems remain framework-tied or best-effort, the consolidation claim fails.","supporting_citations":[],"review_version":1}