{"id":"e68fa472-464b-4163-ae22-797baca343b1","arxiv_id":"2512.00491","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"An LLM with a deterministic arithmetic tool can drive TCP state/flag decisions and complete simulated sessions, where pure LLMs cannot.","lead":"Smart-TCP rewires TCP's connection logic so an AI language model decides state transitions and packet flags, while a separate arithmetic module computes all sequence and acknowledgement numbers. The authors report that this split lets simulated TCP sessions run to completion where pure language models fail.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"End-to-end test is closed-loop: 93.33% measures self-consistency between two Smart-TCP agents, not TCP conformance.","rationale":"The paper's strongest evidence is the end-to-end success rate. The most load-bearing requirement for that evidence is that 'success' means correct TCP behavior. In the current design, success means the two agents complete a session under their own rules. Since both sides use the same model and ALU, they are effectively checking each other's homework. The retrospective label reconstruction compounds the issue because it lacks external validation. This concern does not disprove the architectural idea of LLM+ALU, but it invalidates the specific claim of 93.33% as proof of TCP feasibility. The reader's CONDITIONAL verdict is appropriate; after an interoperability test, the verdict could move to ACCEPT if clean, or down if it fails. Therefore no change to the reader's verdict.","tokens_in":98,"tokens_out":3541,"duration_ms":48671,"concrete_test":"Connect a Smart-TCP agent to an unmodified Linux kernel TCP stack (e.g., via TUN/TAP) in both directions: agent as client to kernel server, and kernel client to agent as server. Run 30 full-lifecycle sessions with random ISNs. Capture all packets and check them against an independent RFC 9293 FSM verifier (e.g., Wireshark's TCP analyzer or a scripted state machine). A pass requires the kernel to accept every segment (handshake, data, FIN) and zero FSM violations on both sides. If Smart-TCP interoperates cleanly with the kernel, the concern is resolved; if the kernel rejects segments or the verifier flags violations, the current 93.33% only shows mutual consistency.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section IV-D deploys two Smart-TCP agents as client and server and reports a 93.33% trial accuracy. Because both endpoints are the same agent, the test is self-referential: any deviation from RFC 9293 that both agents share will not cause a failure. The paper provides no independent TCP stack, no reference implementation, and no packet-level FSM verification. The 93.33% therefore demonstrates that two copies of the model can agree on their own protocol interpretation, not that Smart-TCP implements TCP correctly. This is compounded by Sec. III-B3, where the training labels are generated by a 'custom retrospective analysis script' that encodes the authors' TCP assumptions; the model inevitably inherits those assumptions. Without an external correctness anchor, the central claim of 'autonomous TCP' is unsupported.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"Smart-TCP proposes replacing TCP's deterministic control logic with an agentic LLM-based reasoning core plus a deterministic ALU for sequence/acknowledgment arithmetic. The authors fine-tune Llama-3-8B on labels reconstructed from ISCX-VPN2016 traces with a custom retrospective analysis script, then evaluate static field prediction, anomaly detection, and a dual-agent end-to-end session test. They report 97.22% atomic packet accuracy, 94.5% anomaly detection accuracy, and 93.33% full-lifecycle session success over 30 trials, claiming these results validate the feasibility of an agentic AI-based TCP protocol.","tokens_in":8426,"tokens_out":5898,"duration_ms":62720,"significance":"The idea of decoupling an LLM's protocol reasoning from deterministic arithmetic is a plausible research direction, and the ALU design does guarantee exact sequence-number computation. However, the experimental evidence in the manuscript is entirely internal: the end-to-end test runs two copies of the same agent against each other, and the training labels are produced by an unvalidated custom script. The paper provides no independent TCP implementation, no real network stack, no held-out train/test split for the static results, and no code or reproducible artifacts. The metadata abstract further reports substantially different experimental numbers than the full text. As it stands, the paper does not demonstrate that Smart-TCP implements TCP correctly, only that a fine-tuned LLM can reproduce the authors' own reconstruction of TCP behavior.","major_comments":[{"comment":"The end-to-end validation deploys two Smart-TCP agents as client and server with no external TCP stack or reference implementation. The 93.33% trial accuracy therefore measures self-consistency between two copies of the same model, not conformance to RFC 9293. Any state-machine or flag-handling deviation shared by both agents will not cause a session failure. To support the claim that this is a TCP protocol interaction, the authors must validate against an independent TCP implementation (e.g., a real OS kernel stack on one or both endpoints) or provide packet-level verification against the RFC state machine. Without such an anchor, the central claim is unsupported.","section":"Section IV-D, Table V"},{"comment":"The ground-truth labels used for supervised fine-tuning are reconstructed from raw traces by a 'custom retrospective analysis script' whose logic is neither specified nor validated. The script infers the cognitive state S, the received segment R, the local action A, and the behavioral guide (S', F, PL, Ttask) from packet traces using the authors' TCP assumptions. If those assumptions are simplified or subtly incorrect, the model is trained to imitate the script rather than the actual TCP protocol. The paper provides no manual verification of the reconstructed labels, no comparison with a standard TCP state-machine parser, and no independent validation set. This is load-bearing because every subsequent metric depends on the correctness of this reconstruction.","section":"Section III-B3"},{"comment":"No train/test split is reported for the static field prediction and confusion-matrix experiments. Section III-B describes a dataset of 27 TCP flows and 16,099 packets, but Section IV-A does not state whether the evaluation packets are disjoint from the SFT training data. Without a held-out set, the reported 97.22% atomic accuracy, the 98%+ precision/recall figures, and the confusion matrix may reflect memorization rather than generalization to unseen packets or flows. The authors must specify the exact split (e.g., by flow or by session) and report metrics on held-out data.","section":"Section IV-A, Tables II and III"},{"comment":"The arXiv metadata abstract reports '99.14% action accuracy on 700 slow-path anomaly and fallback samples' and 'a 100% full-lifecycle success rate over 300 ideal fast-path end-to-end session windows.' The full text, however, reports 94.50% accuracy on 200 error-detection samples (Table IV) and 93.33% trial accuracy over 30 sessions (Table V). These are materially different experimental claims. The authors must reconcile the abstract with the full text or provide the missing experiments. As written, the inconsistency undermines the trustworthiness of the reported results.","section":"Abstract (metadata) vs full text"},{"comment":"The anomaly-detection evaluation uses a balanced test set of 200 synthetic error samples (100 order errors and 100 flag errors) that appear to be generated with the same procedure as the training error dataset. There is no real or out-of-distribution anomalous traffic, and no confidence interval for the 94.5% accuracy. The robustness claim is therefore limited to the specific synthetic error distribution used for training, and its transfer to real network anomalies is not demonstrated.","section":"Section IV-C"}],"minor_comments":[{"comment":"The bullet list for the termination phase is duplicated: the same 'Termination' bullet appears twice, once with a shorter description and once with a longer one. This should be fixed.","section":"Section II"},{"comment":"The sentence 'Section IV -Avalidates the fidelity' has a spacing typo; it should be 'Section IV-A validates.'","section":"Section IV-A"},{"comment":"With only 30 sessions, the 93.33% success rate corresponds to 28 of 30 trials. Reporting a confidence interval or the exact failure cases would help assess reliability, especially since the phase-level results show 2/30 failures in the termination phase.","section":"Section IV-D"},{"comment":"The paper says 27 flows are extracted from ISCX-VPN2016, but the dataset is described as 'encrypted and VPN traffic.' The relevance of this dataset for general TCP control logic, which does not inspect payload content, is not discussed.","section":"Section III-B1"}],"recommendation":"reject","confidential_remarks":"I would not encourage a resubmission without fundamental changes. The closed-loop dual-agent test and unvalidated label reconstruction are not fixable by a simple revision; they require a re-implementation of the evaluation with an external TCP stack, proper data splits, and a reconciliation of the abstract with the full text. The paper may have a kernel of a useful idea, but the current evidence does not meet the bar for a networking journal."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Worth a look if you care about LLM-native transport. The core idea is clean: split TCP logic into an LLM cognitive core that decides state transitions, flags, payload length, and an ALU tool that does all 32-bit Seq/Ack arithmetic, glued by JSON tool calls. No prior work in their references turns TCP's internal control logic into an LLM agent with a deterministic arithmetic tool. That is a genuine architectural contribution, and the static field-level results (97.22% atomic accuracy vs. 43% and below for few-shot LLMs) support the basic claim that fine-tuning plus tool use beats prompting on this task. The zero baseline performance in data transfer for pure LLMs is also consistent with known arithmetic weaknesses.\n\nThe soft spot is the end-to-end experiment. Both endpoints are two copies of the same Smart-TCP agent. A 93.33% success rate in that closed loop demonstrates that the two agents can agree on their own protocol interpretation. It does not demonstrate conformance to RFC 9293. If both agents share the same deviation, the session still succeeds. That is a real limitation, not a nit, and the paper has no independent TCP stack, no reference implementation, no packet-level FSM verification. The label-generation pipeline makes this worse: Section III-B3 reconstructs ground-truth labels with a custom retrospective analysis script that encodes the authors' TCP assumptions. The model can be perfectly fine-tuned to those assumptions and still fail against a real kernel.\n\nThere are also presentation problems. The metadata abstract reports 99.14% on 700 samples and 100% on 300 sessions; the full text reports 93.33% on 30 sessions. Those numbers are not reconciled. There is no stated train/test split, no code, no data, no confidence intervals, and the error-detection test is 200 samples. For a paper whose central evidence is a 28/30 success rate, that is thin.\n\nWhat is good: the architecture is simple enough to reproduce, the failure analysis in Table III is honest, and the baseline comparisons are reasonable in a narrow sense. The ALU comparison is not a model prediction, though; the ALU's 100% Ack accuracy is by construction.\n\nBottom line: this is a promising proof-of-concept that needs sharper evaluation, artifact release, and an external correctness anchor. A serious referee could help, but the paper should be sent back for major revision rather than accepted on current evidence.","headline":"Plausible LLM/ALU split for TCP control, but the headline 93.33% measures self-consistency between two identical agents, not TCP conformance.","tokens_in":8820,"tokens_out":2038,"would_cite":false,"duration_ms":21906,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"By splitting TCP's reasoning from its arithmetic, Smart-TCP claims an LLM agent can run a full connection's lifecycle and reach 93.33% session success where pure LLMs get 0%.","keywords":["agentic AI","Large Language Models","TCP protocol","sequence number arithmetic","protocol state machine","tool-augmented agents","supervised fine-tuning","anomaly detection"],"falsifier":"Run the trained agent as one endpoint against a stock operating-system TCP stack over a real network with packet loss and out-of-order delivery, and check whether Seq/Ack remain consistent and the session completes at rates near 93%. Alternatively, feed the retrospective script a trace whose correct state/action labels are known from an independent validator; if the script cannot reproduce those labels, the training-ground truth behind all accuracy numbers is not trustworthy.","tokens_in":8021,"feed_emoji":"🤖","tokens_out":6784,"duration_ms":61299,"temperature":0.7,"pith_summary":"The paper tries to establish that TCP's core control logic—traditionally a fixed state machine with exact sequence-number arithmetic—can be re-implemented as an autonomous AI agent. Its design splits the protocol brain: a fine-tuned large language model decides state transitions, control flags, payload lengths, and which calculation to invoke, while a deterministic arithmetic logic unit (ALU) performs every 32-bit sequence and acknowledgment computation. The authors claim this decoupling overcomes the arithmetic unreliability that makes pure LLM implementations fail, and they support it with experiments: 97.22% atomic packet accuracy in static prediction, 94.5% anomaly-detection accuracy, and 93.33% success over 30 full handshake–data-transfer–termination sessions between two Smart-TCP agents, versus 0% for the LLM baselines. A sympathetic reader would care because, if true, it turns protocol internals from fixed code into adaptive decision-making without sacrificing the precision that networking requires.","feed_headline":"LLM agent runs TCP at 93% success with a dedicated arithmetic unit","feed_subtitle":"Protocol intelligence stays in a fine-tuned model; exact packet numbers move to deterministic math.","key_machinery":"The paper's central machinery is the decoupled cognitive/computational split. The LLM is formalized as a function mapping the reconstructed internal state S, received segment R, and local action A to a next state S′, flags F, payload length PL, and a tool-invocation command Ttask; the Arithmetic Logic Unit (ALU) is formalized as a function returning exact 32-bit Seq and Ack numbers given Ttask, S, and R. Structured JSON encodes the cognitive input and output, and a 'retrospective analysis script' reconstructs training labels from raw traffic. The dual-agent interaction framework instantiates two such agents, letting handshake, data transfer, and termination emerge from per-agent decisions ra","core_discovery":"The central claim is that deterministic protocol arithmetic and adaptive protocol reasoning can and should be separated. Smart-TCP reframes TCP's core logic as an agent: the LLM is the cognitive core, processing state, received segments, and local action to decide the next state, control flags, payload length, and a tool-invocation command; the ALU computes the exact sequence and acknowledgment numbers and returns them; the agent assembles the segment and updates its state. The authors argue that this agentic paradigm overcomes the arithmetic limitations of pure LLM protocol implementations, which they say fail on multi-operand addition and which their own baselines confirm collapse during d","pith_inferences":["The architecture is generic enough to extend to other stateful protocols with exact arithmetic—QUIC's packet-number spaces, for instance—so if Smart-TCP's numbers hold, the same LLM-plus-tool template could be applied beyond TCP.","The closed-world validation means the 93.33% figure is a test of the framework's internal consistency, not of interoperability; placing a Smart-TCP agent opposite a real kernel stack would test whether the fine-tuned model's state-transition priors survive the messy conditions TCP encounters in the wild.","Because the training corpus is only 27 flows totaling 16,099 packets, the robustness of the state-transition confusion (5%+ on closure states) is unknown at scale; a larger, more diverse trace set is a natural next test."],"forward_implications":["If the architecture works as reported, a protocol's control logic can be learned from trace data rather than written by hand, since the SFT-trained LLM reproduces the state machine with high precision on critical states.","Because the ALU owns sequence and acknowledgement computation, the LLM only needs to choose a Ttask command; this relaxes the arithmetic demands on the model and explains why Smart-TCP hits 100% on those fields while baselines stall near 49%.","The dual-agent testbed shows that two Smart-TCP agents can sustain a full handshake-data-termination lifecycle, meaning protocol correctness no longer requires a single monolithic state machine.","The same agent that executes TCP can also police it: the error-detection test at 94.5% accuracy suggests a protocol agent can recognize its own violations, opening the door to self-healing protocol logic."],"fun_headline_variants":["AI agent runs TCP: LLM decides, ALU computes numbers","Smart-TCP: Agentic AI separates reasoning from arithmetic","LLM + ALU combo hits 99% action accuracy in TCP","TCP gets AI brain: fast/slow paths plus deterministic math","Smart-TCP: AI handles anomalies, math stays exact"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is that the custom retrospective analysis script and the closed two-agent environment faithfully represent real TCP semantics; if the reconstructed training labels or the simulator bake in the authors' own simplified assumptions, the 93.33% session success and 94.5% anomaly accuracy may not transfer to real network traffic.","fun_headline_variants_meta":{"raw":{"variants":["AI agent runs TCP: LLM decides, ALU computes numbers","Smart-TCP: Agentic AI separates reasoning from arithmetic","LLM + ALU combo hits 99% action accuracy in TCP","TCP gets AI brain: fast/slow paths plus deterministic math","Smart-TCP: AI handles anomalies, math stays exact"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000253,"raw_usage":{"total_tokens":1399,"prompt_tokens":738,"completion_tokens":661,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":482,"completion_tokens_details":{"reasoning_tokens":574}},"tokens_in":482,"tokens_out":661,"duration_ms":7285,"temperature":1.0,"reasoning_tokens":574,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-03T19:24:58.036118+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the trained agent as one endpoint against a stock operating-system TCP stack over a real network with packet loss and out-of-order delivery, and check whether Seq/Ack remain consistent and the session completes at rates near 93%. Alternatively, feed the retrospective script a trace whose correct state/action labels are known from an independent validator; if the script cannot reproduce those labels, the training-ground truth behind all accuracy numbers is not trustworthy.","supporting_citations":[],"review_version":1}