Pith. sign in

REVIEW 2 major objections 4 minor 29 references

AI-native systems are systems in which an AI autonomously rewrites implementations under verification and a human-owned purpose.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

AI-native systems are defined by an AI holding autonomous revision authority over the system's own implementation, verified by a fallback and escalation detector, with human ownership of purpose.

T0 review reviewed 2026-08-01 challenge →

load-bearing objection A genuinely useful conceptual definition of 'AI-native' — the revision-authority ladder and the occupancy/authority split are new and will be cited; the fallback-composition caveat is real but openly acknowledged and doesn't sink the definition. the 2 major comments →

arxiv 2607.21659 v1 pith:5FB3G3M2 submitted 2026-07-22 cs.AI cs.OS

Defining AI-Native Systems: Autonomy as Revision Authority

Cheng Tan This is my paper
classification cs.AI cs.OS
keywords AI-native systemsrevision authorityautonomous systemsmachine learning for systemsself-rewritingescalation detectionverification and fallbackdecision-level model
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper gives 'AI-native' a precise technical definition, replacing the marketing usage. The defining property is not how capable the AI is but how much revision authority the system delegates: who is allowed to change the system's own decisions. An AI-native system is one where an AI autonomously revises implementations (not just tunes parameters), controls which deciders occupy decision points, runs every revision through a verification procedure with a verified fallback, and leaves purpose and correctness human-owned. This matters because coding agents are already writing systems code, and the field needs an auditable criterion for when a system genuinely has the property, to guide safe deployment.

Core claim

The central claim is a formal definition: a system is AI-native if and only if it satisfies four conditions—strong-S2 autonomy (an AI autonomously revises implementations and, via an escalation detector ε, autonomously determines when revisions are needed), allocation authority (the AI controls the allocation map α across levels L2–L4, deciding which decider occupies each decision point), ρ-verified revision (every AI-generated revision passes a verification procedure and a verified non-AI fallback is retained), and a human-owned envelope (purpose L0 and the objective and invariants of L1 remain under human control). Compactly: AI-native = strong-S2 × α-authority × ρ-verification, under a hu

What carries the argument

The machinery is a decision-level model that stratifies a system into L0 purpose, L1 design, L2 implementation, L3 policy, and L4 runtime, along with two orthogonal axes: allocation α (who decides) and verification ρ (who admits revisions). The pivotal distinction is occupancy (who executes a decision) versus revision authority (who may change it). The revision-authority ladder grades systems by the highest level at which an AI can adapt autonomously. The definition combines strong-S2 (autonomous implementation rewriting with an escalation detector), α-authority over decider allocation, ρ-verification with a retained fallback, and human-owned L0.

Load-bearing premise

The load-bearing premise is that a verified non-AI fallback can be composed with an AI-generated revision so that the deployed composite's worst case is guaranteed to be the fallback's by construction—the paper cites a precedent but provides no mechanism or proof for arbitrary systems.

What would settle it

Construct an AI-rewritten implementation that passes the verification procedure ρ but, when the system switches to the retained fallback after a failed revision, corrupts shared state or violates the worst-case guarantee; this would refute condition 3 and collapse the safety rationale for autonomous rewriting.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • A system that merely contains a learned model on the hot path is not AI-native; occupancy without revision authority confers no autonomy.
  • The definition separates capability from authority: a system built on narrow ML can be AI-native if an agent rewrites its heuristics under verification, while a one-off superhuman algorithm-discovery run is not.
  • Grade membership must be evidenced by an auditable certificate (a verified code diff with its passing verification record, escalation trigger evidence, and retained fallback), not asserted.
  • The dangerous configuration is the middle grade—runtime ML in production—where autonomy invites trust but does not own failure; verified-fallback composition is preferable to human-in-the-loop handback under time pressure.
  • The practical ceiling is self-architecting (S1) within a negotiated envelope, because redesign changes the verification procedure itself; an S1 certificate must include a re-derived verification procedure a human can still audit.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the definition becomes standard, claims of 'AI-native' become checkable compliance claims: a vendor would have to produce the certificate, much like a safety case, rather than a benchmark score.
  • The definition implies a design heuristic: choose the representation so fast-drifting decisions live at lower levels where revision is cheaper and verification lighter—re-stratification as the deepest sense of 'AI-native architecture.'
  • A testable extension: build a benchmark that checks whether real systems satisfy the certificate conditions (autonomous trigger, verification, fallback composition) rather than grading model accuracy on traces.
  • The escalation detector ε is the highest-leverage component; whether existing drift-detection methods can serve as ε, or a genuinely new 'decision procedure over adequacy' is needed, remains an open empirical question.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. This paper proposes a technical definition of 'AI-native' systems, grounded in revision authority rather than AI capability. It introduces a decision-level model that separates occupancy from revision authority, organizes revision authority into a ladder (S3 self-tuning, S2 self-rewriting, S1 self-architecting), and defines an AI-native system as one satisfying strong-S2 autonomy, allocation authority over deciders, verification of all revisions with a retained verified fallback, and a human-owned L0 envelope. The definition is compactly expressed as AI-native = strong-S2 × α-authority × ρ-verification. The paper includes worked classifications, a certificate scheme, a mapping to SAE driving-automation levels, and a discussion of open problems.

Significance. The contribution is timely and conceptually useful. If the definition is accepted, it replaces a marketing term with a precise, auditable property, shifts the ML-for-systems debate from where learned models execute to who may revise system decisions, and draws an instructive analogy to automotive automation. The paper is unusually explicit about the scope and conventionality of its level boundaries (Claim 1 and §3.5) and about the certificate needed for each grade. The central weakness is that one necessary condition of the definition—verified fallback composition—is asserted as 'by construction' in §5 while being listed as an open problem in §7; this makes the claimed 'iff' conditional. The paper's strengths include explicit caveats, a certificate framework that is falsifiable in principle, and a clear separation of occupancy from authority.

major comments (2)
  1. [§5 (condition 3); §7] Condition 3 of the definition claims that because the deployed artifact is fallback⊕p′, its worst case is the fallback's 'by construction.' This is not derived: the Simplex architecture [20] guarantees a bounded, reversible switch for a plant with a fixed state space, but an AI-generated p′ may change internal state layout, add asynchronous side effects, or migrate persistent state, making the switch back to the fallback not bounded or reversible. The manuscript itself hedges with 'given a bounded, reversible switch...' and §7 lists verification and fallback composition as an open problem. Since condition 3 is a necessary conjunct in the 'iff,' the definition is either currently unsatisfiable by any known system or silently imports a nonconstructive composition assumption. Please either provide a concrete composition construction or a class of systems for which the property holds, or ref
  2. [§5, conditions 2 and 4] The definition's 'iff' relies on an unformalized distinction between authority and exercise. Condition 2 says the AI 'controls' the allocation map α and 'determines' which decider occupies each point, while §4 defines grades by 'can perform adaptation autonomously.' These are different modalities: a system in which the AI proposes decider assignments but a human approves them (as in the weak-S2 row of Table 4) would not satisfy condition 2, but the paper gives no test for what 'controls' requires. Similarly, condition 4's 'human-owned envelope' is not backed by a mechanism preventing an L2 revision from effectively altering L0 through behavioral changes. Without a sharper definition of these modalities, the 'iff' is hard to apply even in principle.
minor comments (4)
  1. [§2.2] The phrase 'dissolves the five barriers at a stroke' overstates the case: maintainability and expertise are transformed (the agent pipeline itself becomes a new component to monitor), not dissolved. Suggest softening.
  2. [Table 1] The row 'Decider today' reads 'human + agent tuner code'; this is ambiguous. Likely 'human + agent tuner' or 'human + agent-tuned code'.
  3. [§5] The compact formula uses '×' for conjunction; consider '∧' to avoid confusion with Cartesian product or multiplication.
  4. [§7] 'Re-stratification' is listed as an open problem without cross-referencing its first appearance in §3.5(a) and the S1 discussion in §4. A pointer would help the reader.

Circularity Check

1 steps flagged

Minor self-definitional flourish; no load-bearing circularity.

specific steps
  1. self definitional [§5 (Definition AI-Native System, compact formula); cf. §3.5 closing paragraph]
    "The three factors are exactly the three axes of the extended decision landscape of §3.5—adaptive range on the vertical hierarchy, the allocation axis α, and the verification axis ρ—with the human residue pinned at L0. That the definition factors cleanly along these axes is evidence it carves the space at its joints rather than stipulating a checklist."

    The 'evidence' sentence is self-confirming. §3.5 closes by saying 'The definition that follows (§5) factors cleanly along exactly these three directions—adaptive range on the vertical axis, authority over α, constraint by ρ, with the human residue pinned at L0.' The axes were therefore constructed as the coordinates on which the definition was already going to factor. That the definition then 'factors cleanly along' them is true by construction, not an independent test that it 'carves the space at its joints.' This is a minor rhetorical self-justification rather than a load-bearing derivation: the definition's content stands on its own stipulations and is not fitted to data or imported from a self-citation.

full rationale

This is an explicitly stipulative definitional paper: 'This paper gives it one' (Abstract). The proposed chain (decision-level model → four levels → revision-authority ladder → AI-native definition) is a sequence of definitions and logical classification, not a prediction from fitted parameters, a renamed empirical regularity, or an imported uniqueness theorem. The load-bearing steps I checked are not circular: the level partition of Claim 1 is a definitional trichotomy by binding time and revision cost; the cumulative-downward property of the ladder follows from the generating rule of §3.3; and the SAE/Simplex comparisons are external analogies, not self-citations. The author's self-citations (NN4SysBench [11], Ouroboros [22], LLM-policy [26], NUMA [27]) are used only as illustrative examples of verification or runtime ML and are not load-bearing for the AI-native definition. The one genuine self-referential element is the §5 sentence treating the clean factoring of the definition along the §3.5 axes as evidence of non-stipulation; since §3.5 explicitly designed those axes to host the upcoming definition, this is a minor self-definitional flourish, not a substantive circularity. Separately, the fallback-composition guarantee ('worst case is the fallback's by construction') is conditioned in §5 ('given a bounded, reversible switch with no cross-version state corruption') and listed as an open problem in §7; that is an unresolved correctness/completeness gap, not a circularity. Overall the paper is self-contained and non-circular in its central claim, so the score is 2 for the minor self-definitional flourish.

Axiom & Free-Parameter Ledger

0 free parameters · 4 axioms · 3 invented entities

The framework rests on a few explicit structural assumptions: the exhaustiveness of the L1-L4 classification under a fixed representation convention; the cumulativity of revision authority implied by the generating rule; and the compositionality of verified fallbacks. It also postulates two required components (escalation detector and verification procedure) that are not yet demonstrated.

axioms (4)
  • domain assumption Every decision whose outcome affects system behavior belongs to exactly one of L1–L4, given a fixed representation convention R (Claim 1).
    The comprehensiveness of the level taxonomy is asserted with a short argument; it is not proven formally and depends on R being fixed. If some decisions fall between levels or on other axes (which the paper partially admits via the α and ρ axes), the definition may be incomplete.
  • domain assumption A level-k selection re-parameterizes every level below it (generating rule in §3.3), making revision authority cumulative downward.
    This structural assumption justifies why S3/S2/S1 are cumulative grades and why L4 is excluded. It is plausible but not formally proven for all systems.
  • domain assumption A verified non-AI fallback can be composed with an AI-revised component such that the worst case is the fallback's by construction (Simplex architecture, §5).
    Real-world fallback composition often requires state transfer and can have failure modes; the paper cites Simplex but does not prove this property holds for general systems. This is load-bearing for the safety rationale of the definition.
  • ad hoc to paper There exists an escalation detector ε that maps evidence of saturated L3 adaptation to an L2 regeneration trigger (§4, §7).
    This is a critical component of strong-S2 and AI-native, yet the paper lists it as an open problem. The definition presumes its feasibility.
invented entities (3)
  • Escalation detector ε no independent evidence
    purpose: Autonomously detect when current policy adaptation has saturated and trigger regeneration of the implementation.
    Defined in §4 as a 'decision procedure over the adequacy of decision procedures'. No implementation or empirical demonstration is provided; it is a conceptual requirement.
  • Verification procedure ρ no independent evidence
    purpose: Admit or reject candidate revisions before deployment, with a verified fallback retained.
    Defined in §3.5 as an axis orthogonal to the decision hierarchy. The paper cites existing verification techniques but does not provide a new instantiation; it is a required component of the definition.
  • Allocation authority α no independent evidence
    purpose: Determines which decider occupies each decision point and may reassign deciders.
    An orthogonal ownership dimension introduced in §3.5; the AI-native definition requires an AI to control this allocation across L2–L4. No concrete mechanism is given.

reviewed 2026-08-01 · how reviews work

0 comments
Cite this review

Pith. "Pith review of Defining AI-Native Systems: Autonomy as Revision Authority." pith.science (2026). https://pith.science/paper/5FB3G3M2

@misc{pith2026260721659,
  author       = {Pith},
  title        = {Pith review of: Defining AI-Native Systems: Autonomy as Revision Authority},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5FB3G3M2}},
  note         = {Machine review of arXiv:2607.21659}
}
Share X Bluesky LinkedIn Reddit HN
read the original abstract

AI has begun to write systems code: agents now synthesize, verify, and deploy system components. Despite this shift, "AI-native" remains a marketing term with no precise technical definition. This paper gives it one. We define AI-nativeness along a single axis---authority over the system's own decisions rather than by the capability of the underlying AI models. Building on a decision-level model of a system, we distinguish occupancy (who executes a decision) from revision authority (who may change it), organize revision authority into a ladder---self-tuning, self-rewriting, self-architecting and define a system as AI-native when an AI autonomously rewrites the system's own implementations. The definition further requires an escalation detector, a verification procedure, and a verified fallback, while leaving purpose and correctness human-owned.

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

29 extracted references · 4 canonical work pages

  1. [1]

    2024.Management and Orchestration; Levels of Autonomous Network (TS 28.100, Release 18)

    3GPP. 2024.Management and Orchestration; Levels of Autonomous Network (TS 28.100, Release 18). Technical Report. 3rd Generation Partnership Project. Mirrored as ETSI TS 128 100 V18.0.0

    2024

  2. [2]

    Gordon, and Bohan Zhang

    Dana Van Aken, Andrew Pavlo, Geoffrey J. Gordon, and Bohan Zhang

  3. [3]

    Audrey Cheng, Shu Liu, Melissa Pan, Zhifei Li, Shubham Agarwal, Mert Cemri, Bowen Wang, Alexander Krentsel, Tian Xia, Jongseok Park, Shuo Yang, Jeff Chen, Lakshya Agrawal, Ashwin Naren, Shulu Li, Ruiying Ma, Aditya Desai, Jiarong Xing, Koushik Sen, Matei Zaharia, and Ion Stoica. 2025. Let the Barbarians In: How AI Can Acceler- ate Systems Performance Rese...

    arXiv 2025

  4. [4]

    Audrey Cheng, Shu Liu, Melissa Pan, Zhifei Li, Bowen Wang, Alex Krentsel, Tian Xia, Mert Cemri, Jongseok Park, Shuo Yang, Jeff Chen, Lakshya Agrawal, Aditya Desai, Jiarong Xing, Koushik Sen, Matei Zaharia, and Ion Stoica. 2025. Barbarians at the Gate: How AI is Upending Systems Research.arXiv preprint arXiv:2510.06189(2025)

    arXiv 2025

  5. [5]

    Rohit Dwivedula, Divyanshu Saxena, Sujay Yadalam, Daehyeok Kim, and Aditya Akella. 2025. Vulcan: Instance-Optimal Systems Heuristics Through LLM-Driven Search.arXiv preprint arXiv:2512.25065(2025)

    Pith/arXiv arXiv 2025

  6. [6]

    Nick Feamster and Jennifer Rexford. 2018. Why (and How) Networks Should Run Themselves. InProceedings of the Applied Networking Research Workshop (ANRW). doi:10.1145/3232755.3234555

    arXiv 2018

  7. [7]

    Xuan Feng, Peng Cheng, Qi Chen, Shan Lu, Chieh-Jan Mike Liang, Bogdan Alexandru Stoica, Zhongxin Guo, Jiahang Xu, Tianyin Xu, and Lidong Zhou. 2025. Defining System Intelligence. ACM SIGOPS Blog.https://www.sigops.org/2025/defining-system-intelligence/

    2025

  8. [8]

    Marios Evangelos Kanakis, Ramin Khalili, and Lin Wang. 2022. Ma- chine Learning for Computer Systems and Networking: A Survey. Comput. Surveys55, 4 (2022), 71:1–71:36. doi:10.1145/3523057

    work page doi:10.1145/3523057 2022

  9. [9]

    Kephart and David M

    Jeffrey O. Kephart and David M. Chess. 2003. The Vision of Autonomic Computing.IEEE Computer36, 1 (2003), 41–50. doi:10.1109/MC.2003. 1160055

    work page doi:10.1109/mc.2003 2003

  10. [10]

    Chi, Jeffrey Dean, and Neoklis Polyzotis

    Tim Kraska, Alex Beutel, Ed H. Chi, Jeffrey Dean, and Neoklis Polyzotis

  11. [11]

    Shuyi Lin, Haoyu He, Tianhao Wei, Kaidi Xu, Huan Zhang, Gagandeep Singh, Changliu Liu, and Cheng Tan. 2024. NN4SysBench: Character- izing Neural Network Verification for Computer Systems. InAdvances in Neural Information Processing Systems 37 (NeurIPS), Datasets and Benchmarks Track.https://openreview.net/forum?id=mhjRudcHcB

    2024

  12. [12]

    Martin Maas. 2020. A Taxonomy of ML for Systems Problems.IEEE Micro40, 5 (2020), 8–16. doi:10.1109/MM.2020.3012883

    arXiv 2020

  13. [13]

    Andersen, Michael Isard, Mohammad Mahdi Ja- vanmard, Kathryn S

    Martin Maas, David G. Andersen, Michael Isard, Mohammad Mahdi Ja- vanmard, Kathryn S. McKinley, and Colin Raffel. 2020. Learning-based Memory Allocation for C++ Server Workloads. InProceedings of the 25th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS)

    2020

  14. [14]

    AGI-Complete

    Martin Maas, Milad Hashemi, Kathryn McKinley, and Parthasarathy Ranganathan. 2026. AI for Systems is “AGI-Complete”.ACM SIGOPS Operating Systems Review60, 1 (2026), 21–29

    2026

  15. [15]

    Margaret Mitchell, Avijit Ghosh, Alexandra Sasha Luccioni, and Giada Pistilli. 2025. Fully Autonomous AI Agents Should Not be Developed. arXiv preprint arXiv:2502.02649.https://arxiv.org/abs/2502.02649

    arXiv 2025

  16. [16]

    Meredith Ringel Morris, Jascha Sohl-Dickstein, Noah Fiedel, Tris Warkentin, Allan Dafoe, Aleksandra Faust, Clement Farabet, and Shane Legg. 2024. Position: Levels of AGI for Operationalizing Progress on the Path to AGI. InProceedings of the 41st International Conference on Machine Learning (ICML) (Proceedings of Machine Learn- ing Research, Vol. 235). PML...

    2024

  17. [17]

    Alexander Novikov, Ngân V ˜u, Marvin Eisenberger, et al . 2025. Al- phaEvolve: A Coding Agent for Scientific and Algorithmic Discovery. arXiv preprint arXiv:2506.13131(2025)

    Pith/arXiv arXiv 2025

  18. [18]

    Mowry, Matthew Perron, Ian Quah, Siddharth Santurkar, Anthony Tomasic, Skye Toor, Dana Van Aken, Ziqi Wang, Yingjun Wu, Ran Xian, and Tieying Zhang

    Andrew Pavlo, Gustavo Angulo, Joy Arulraj, Haibin Lin, Jiexi Lin, Lin Ma, Prashanth Menon, Todd C. Mowry, Matthew Perron, Ian Quah, Siddharth Santurkar, Anthony Tomasic, Skye Toor, Dana Van Aken, Ziqi Wang, Yingjun Wu, Ran Xian, and Tieying Zhang. 2017. Self- Driving Database Management Systems. In8th Biennial Conference on Innovative Data Systems Research (CIDR)

    2017

  19. [19]

    2021.Taxonomy and Definitions for Terms Related to Driving Automation Systems for On-Road Motor Vehicles

    SAE International. 2021.Taxonomy and Definitions for Terms Related to Driving Automation Systems for On-Road Motor Vehicles. Technical Report J3016_202104. SAE International

    2021

  20. [20]

    Lui Sha. 2001. Using Simplicity to Control Complexity.IEEE Software 18, 4 (2001), 20–28

    2001

  21. [21]

    Zhenyu Song, Kevin Chen, Nikhil Sarda, Deniz Altınbüken, Eugene Brevdo, Jimmy Coleman, Xiao Ju, Pawel Jurczyk, Richard Schooler, and Ramki Gummadi. 2023. HALP: Heuristic Aided Learned Prefer- ence Eviction Policy for YouTube Content Delivery Network. In20th USENIX Symposium on Networked Systems Design and Implementation (NSDI). 1149–1163

    2023

  22. [22]

    Cheng Tan, Changliu Liu, Zhihao Jia, and Tianhao Wei. 2023. Building Verified Neural Networks for Computer Systems with Ouroboros. In Proceedings of Machine Learning and Systems (MLSys), Vol. 5

    2023

  23. [23]

    2020.An Introduction to Self-Adaptive Systems: A Con- temporary Software Engineering Perspective

    Danny Weyns. 2020.An Introduction to Self-Adaptive Systems: A Con- temporary Software Engineering Perspective. Wiley-IEEE Press

    2020

  24. [24]

    Nan Wu and Yuan Xie. 2023. A Survey of Machine Learning for Computer Architecture and Systems.Comput. Surveys55, 3 (2023), 54:1–54:39. doi:10.1145/3494523

    work page doi:10.1145/3494523 2023

  25. [25]

    Tzu-Wei Yang, Seth Pollen, Mustafa Uysal, Arif Merchant, and Homer Wolfmeister. 2022. CacheSack: Admission Optimization for Google Datacenter Flash Caches. In2022 USENIX Annual Technical Conference (USENIX ATC). 1021–1036

    2022

  26. [26]

    Yibo Zhao and Cheng Tan. 2025. Can LLMs Replace Time-Tested System Policies? Perhaps. InProceedings of the 16th ACM SIGOPS Asia- Pacific Workshop on Systems (APSys). 168–175. doi:10.1145/3725783. 3764405

    work page doi:10.1145/3725783 2025

  27. [27]

    Yibo Zhao, Tianyuan Wu, Hui Xue, Qi Chen, Zhenhua Han, Zikai Xu, Yuntai Chang, Rui Gao, Steve Deng, Jui-Hao Chiang, Mingxia Li, Yuqing Yang, Cheng Tan, Fan Yang, Peng Cheng, Yongqiang Xiong, Lili Qiu, and Lidong Zhou. 2026. Virtual Machine NUMA Placement at Scale: Learning the Norm, Shielding the Tail. InProceedings of Machine Learning and Systems (MLSys)

    2026

  28. [2017]

    InProceedings of the 2017 ACM Inter- national Conference on Management of Data (SIGMOD)

    Automatic Database Management System Tuning Through Large-scale Machine Learning. InProceedings of the 2017 ACM Inter- national Conference on Management of Data (SIGMOD). 1009–1024. doi:10.1145/3035918.3064029

    arXiv 2017

  29. [2018]

    InProceedings of the 2018 Cheng Tan International Conference on Management of Data (SIGMOD)

    The Case for Learned Index Structures. InProceedings of the 2018 Cheng Tan International Conference on Management of Data (SIGMOD). 489–504

    2018

This paper was first reviewed by deepseek-v4-flash on August 1, 2026.