{"id":"b891560e-1ce8-4880-85da-24de3afcfa51","arxiv_id":"2607.21659","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"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.","lead":"This paper proposes a precise definition of 'AI-native' systems: a system is AI-native when an AI agent autonomously rewrites the system's own implementation code, under human-set goals and safety checks. It introduces a ladder of autonomy (self-tuning, self-rewriting, self-architecting) and argues that the key axis is who holds authority to change system decisions, not how smart the AI is.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Fallback-composition guarantee in §5 (condition 3) is asserted, not derived: for stateful systems the 'worst case = fallback' claim is unproven, which undercuts the 'iff' in the central definition.","rationale":"The reader's weakest assumption is exactly the fallback-composition guarantee, and I agree that this is the most load-bearing point: the safety rationale and the 'iff' in Definition §5 both rest on it. However, the paper is a position paper: it explicitly lists fallback composition as an open problem in §7 and does not claim a working construction. The definition is stipulative and can still be a useful target even if no current system satisfies all conditions. Thus, the concern is real but does not overturn the ACCEPT verdict; it reinforces the need to read condition 3 as a normative requirement and an open engineering problem rather than an established guarantee. A concrete experiment like the one proposed would determine whether the 'by construction' language is even achievable for representative systems, and would sharpen the definition if it fails. But this is a refinement, not a rejection, of the paper's central proposal.","tokens_in":13532,"tokens_out":8207,"duration_ms":75726,"concrete_test":"Build a small stateful system (e.g., an in-memory key-value cache) and implement the fallback⊕p′ pattern from §4/§5. Have an AI agent generate a candidate p′ that changes the state representation or introduces asynchronous background writes. Then fault-inject a failure of p′ mid-execution and force a switch to the verified non-AI fallback. Check whether the fallback can resume without violating invariants such as 'no lost or corrupted updates.' If the composite's worst-case behavior exceeds the fallback's, then condition 3 is not guaranteed 'by construction,' and the definition must either be revised to include explicit state-transfer compatibility requirements or weakened from an iff to an aspirational characterization.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central definition (§5) makes ρ-verified revision with a retained verified non-AI fallback a necessary condition for AI-nativeness, and the compact formula 'AI-native = strong-S2 × α-authority × ρ-verification' inherits this. The paper claims in §4 that the deployed artifact is fallback⊕p′ and 'its worst case is the fallback’s by construction,' citing the Simplex architecture [20]. But the paper provides no mechanism or proof for arbitrary systems: Simplex guarantees apply to a plant with a fixed state space and a decision module that can switch to a verified controller. For a system whose AI-generated revision p′ changes internal state layout, adds asynchronous side effects, or migrates persistent state, switching back to the fallback is not a bounded, reversible operation. The paper itself hedges with 'given a bounded, reversible switch with no cross-version state corruption,' but no construction for this is given, and §7 lists fallback composition as an open problem. Since condition 3 is part of the 'iff,' either the definition is empty (no current/known system can satisfy it) or it silently imports a nonconstructive assumption. This is the load-bearing point: the safety rationale for autonomous rewriting depends entirely on this composition property, so without a proof or a concrete composition mechanism, the central claim is conditional rather than established.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":13872,"tokens_out":7264,"duration_ms":60636,"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":[{"comment":"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","section":"§5 (condition 3); §7"},{"comment":"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.","section":"§5, conditions 2 and 4"}],"minor_comments":[{"comment":"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.","section":"§2.2"},{"comment":"The row 'Decider today' reads 'human + agent tuner code'; this is ambiguous. Likely 'human + agent tuner' or 'human + agent-tuned code'.","section":"Table 1"},{"comment":"The compact formula uses '×' for conjunction; consider '∧' to avoid confusion with Cartesian product or multiplication.","section":"§5"},{"comment":"'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.","section":"§7"}],"recommendation":"major_revision","confidential_remarks":"The paper is a strong conceptual contribution and the internal argument is largely coherent. The main issue is the fallback-composition guarantee: it is load-bearing for the central definition and currently asserted rather than established. A revision that either supplies a construction, narrows the claim to a class of systems, or explicitly reframes condition 3 as a research target would resolve the concern. I would support publication after such a revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague — this is a solid, useful paper. It gives 'AI-native' a precise meaning: a system is AI-native when an AI has revision authority over the system's own implementation, with an escalation detector, verification procedure, and a human-owned envelope. The key move is separating occupancy (who executes a decision) from revision authority (who may change it). That distinction is clean and does real work; it lets the author place runtime ML on the occupancy axis, where it has no autonomy, and define autonomy purely as authority to revise. The four-level decision hierarchy (design, implementation, policy, runtime) with the L0 purpose level above and the α and ρ axes orthogonal to it is a coherent organizing framework. It maps sensibly onto SAE levels and MAPE-K and explicitly positions itself against the capability ladders (Maas, etc.). The paper is honest: it flags the L2/L3 boundary as conventional, admits S1 is aspirational, and lists four open problems in §7. This is a position paper, not a theorem paper, and it doesn't overclaim.\n\nThe soft spot the stress-test flags is real but not fatal. §5 condition 3 requires a verified fallback and says the deployed composite's worst case is the fallback's 'by construction,' citing Simplex. As the stress-test notes, this only holds under a bounded, reversible switch with no cross-version state corruption — and the paper itself says exactly that, then lists fallback composition as an open problem in §7. So the definition does not silently import a guarantee; it names a condition that is currently hard to meet. For a stipulative definition, that's acceptable. If the author tried to claim existing systems satisfy it, that would be a problem, but the paper doesn't. It actually uses the definition to say what would need to be built.\n\nOne smaller quibble: the paper is a bit long and the SAE analogy, while apt, is stretched in places (Lesson 4 relocates the comparison to the fleet loop, which is fair but could be shorter). The certificates in Table 3 are a nice touch but underdeveloped.\n\nBottom line: this deserves a serious referee. It's a genuine conceptual contribution that gives the systems community a vocabulary for a term currently used as marketing. I'd bring it to my reading group and I'd cite it in my own writing on AI-driven systems. Recommend: send to peer review as a position/taxonomy paper.","headline":"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.","tokens_in":14304,"tokens_out":2302,"would_cite":true,"duration_ms":18885,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"AI-native systems are systems in which an AI autonomously rewrites implementations under verification and a human-owned purpose.","keywords":["AI-native systems","revision authority","autonomous systems","machine learning for systems","self-rewriting","escalation detection","verification and fallback","decision-level model"],"falsifier":"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.","tokens_in":13403,"feed_emoji":"🤖","tokens_out":5660,"duration_ms":43619,"temperature":0.7,"pith_summary":"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.","feed_headline":"AI-native defined: autonomy is revision authority, not model smarts","feed_subtitle":"A precise definition lets engineers and regulators tell real autonomy from a marketing label.","key_machinery":"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.","core_discovery":"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","pith_inferences":["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."],"forward_implications":["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."],"fun_headline_variants":["AI-native: authority to rewrite, not just execute","Revision authority, not model smarts, defines AI-native","AI-native defined: autonomy with verification and human leash","Precise AI-native: when AI rewrites implementation, under control"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["AI-native: authority to rewrite, not just execute","Revision authority, not model smarts, defines AI-native","AI-native defined: autonomy with verification and human leash","Precise AI-native: when AI rewrites implementation, under control"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000209,"raw_usage":{"total_tokens":1204,"prompt_tokens":665,"completion_tokens":539,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":409,"completion_tokens_details":{"reasoning_tokens":483}},"tokens_in":409,"tokens_out":539,"duration_ms":5695,"temperature":1.0,"reasoning_tokens":483,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T09:23:44.696977+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[],"review_version":1}