Smart-TCP: An Agentic AI-based Autonomous and Adaptive TCP Protocol

Kezhi Wang; Kun Yang; Yizhe Zhao; Yule Han

REVIEW 5 major objections 4 minor 9 references

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%.

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 ↗

T0 review · deepseek-v4-flash

2026-08-03 19:24 UTC pith:7F7NYI62

load-bearing objection Plausible LLM/ALU split for TCP control, but the headline 93.33% measures self-consistency between two identical agents, not TCP conformance. the 5 major comments →

arxiv 2512.00491 v3 pith:7F7NYI62 submitted 2025-11-29 cs.NI

Smart-TCP: An Agentic AI-based Autonomous and Adaptive TCP Protocol

Yule Han , Kezhi Wang , Yizhe Zhao , Kun Yang This is my paper

classification cs.NI

keywords agentic AILarge Language ModelsTCP protocolsequence number arithmeticprotocol state machinetool-augmented agentssupervised fine-tuninganomaly detection

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 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.

Core claim

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

What carries the argument

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

Load-bearing premise

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.

What would settle it

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.

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

Share X Bluesky LinkedIn Reddit HN

If this is right

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.

Where Pith is reading between the lines

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

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.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

Plausible LLM/ALU split for TCP control, but the headline 93.33% measures self-consistency between two identical agents, not TCP conformance.

read the 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.

The 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.

There 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.

What 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.

Bottom 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.

Referee Report

5 major / 4 minor

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.

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 (5)

[Section IV-D, Table V] 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 III-B3] 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 IV-A, Tables II and III] 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.
[Abstract (metadata) vs full text] 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 IV-C] 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.

minor comments (4)

[Section II] 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 IV-A] The sentence 'Section IV -Avalidates the fidelity' has a spacing typo; it should be 'Section IV-A validates.'
[Section IV-D] 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 III-B1] 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.

Circularity Check

3 steps flagged

End-to-end validation is closed-loop: 93.33% trial accuracy measures two Smart-TCP agents' self-consistency, not TCP conformance; ALU arithmetic accuracy is guaranteed by construction.

specific steps

self definitional [Section IV-D (End-to-End Functional Validation), Table V]
"We deploy two autonomous Smart-TCP agents to function respectively as the Client and Server, establishing a complete end-to-end connection. ... The Smart-TCP agent maintains consistent performance across all interaction phases, achieving a trial accuracy of 93.33% across 30 independent TCP sessions."

The success criterion is defined entirely inside a system whose two endpoints are copies of the same trained agent. Any TCP interpretation that both copies share—including a deviation from RFC 9293—will be mutually consistent and will not cause a failed session. The 93.33% therefore shows that two instances of the same model can agree with each other, not that the agent implements TCP correctly. The paper uses this number as feasibility evidence for 'agentic AI-based TCP protocol', but no independent stack, reference FSM, or external verifier is in the loop.
fitted input called prediction [Section III-B3 (Retrospective State Reconstruction), Section IV-A (Fig. 2, Table II)]
"We develop a custom retrospective analysis script that can reconstruct this decision context. ... We analyze TCP rules to derive the arithmetic task type Ttask required for Seq and Ack generation. Ultimately, the reconstructed (S, R, A) serves as model input, while (S′, F, PL, Ttask) forms the complete behavioral guide for supervised fine-tuning."

The SFT labels are not externally verified ground truth; they are the output of the authors' own TCP-rule analysis. The model is trained to imitate that analysis, and Sections IV-A/B then report high accuracy on the same kind of reconstructed labels. Any systematic error in the reconstruction script is therefore invisible: the model inherits it and the test rewards it. The reported 'prediction' accuracy measures consistency with the authors' rule encoding, not conformance to an independent TCP specification.
self definitional [Section II (Agent Framework Overview) and Section IV-A (Fig. 2 discussion)]
"ALU: As the arithmetic engine, this deterministic unit is responsible for all high-precision 32-bit arithmetic operations. Its sole responsibility is to precisely calculate the sequence and acknowledgment numbers, ensuring absolute computational accuracy. ... In contrast, our Smart-TCP agent maintains 100% accuracy."

The ALU is a deterministic calculator, so its output is correct by construction for whatever task it is given. Reporting 100% accuracy on Seq/Ack fields for Smart-TCP is therefore a statement about the architecture, not a measured property of the learned model. Used as a comparative result ('These results demonstrate that decoupling the arithmetic burden from the cognitive core effectively overcomes the computational bottlenecks'), it is a tautology rather than an empirical validation.

full rationale

The paper has no load-bearing self-citation chain; its central architecture and baselines contain genuine independent content (SFT on ISCX-VPN2016 traces, anomaly detection, and comparisons to three general-purpose LLMs). However, the load-bearing end-to-end claim is closed-loop: both endpoints are the same Smart-TCP agent, so 93.33% trial accuracy is a self-consistency measurement rather than a test of TCP conformance. The 100% arithmetic accuracy of the ALU is definitionally guaranteed by the use of a deterministic calculator. The retrospective label-reconstruction script supplies the only correctness anchor for the learned cognitive core, but it is unvalidated, so the static 'predictions' in Section IV-A are agreements with the authors' own rule encoding. These issues are partial circularities rather than a fully forced derivation, so the score is 6 rather than 8 or 10.

Axiom & Free-Parameter Ledger

2 free parameters · 5 axioms · 2 invented entities

The central claim rests on a supervised-learning pipeline whose labels are produced by an unreleased custom script, an unstated train/test split, and a closed simulator. The ALU removes arithmetic error by construction, so the learned part must carry the protocol-logic generalization; no independent evidence is provided that the learned logic transfers beyond the training distribution.

free parameters (2)

LoRA adapter weights (Smart-TCP LLM core)
All logical decisions (state, flags, payload length, tool selection) are SFT-fitted on reconstructed ISCX-VPN2016 traces; the weights are not released, so the model's behavior cannot be independently instantiated.
SFT hyperparameters (lr 1e-4, epochs 5, LoRA config) = learning_rate=1e-4, epochs=5
Chosen by hand and not ablated; the reported accuracy depends on this specific configuration.

axioms (5)

standard math TCP state machine and 32-bit sequence/ack arithmetic are as defined by RFC 9293.
Used throughout to derive labels and simulator behavior; treated as established external standard.
ad hoc to paper The custom retrospective analysis script reconstructs correct ground-truth (S,R,A,S',F,PL,Ttask) tuples from raw traces.
Section III-B3 describes the script but provides no validation or release; the entire SFT training depends on this unverified labeling.
domain assumption ISCX-VPN2016's 27 extracted TCP flows are representative of full-lifecycle TCP behavior for training and testing protocol logic.
Section III-B1 sources only 27 flows / 16,099 packets from one dataset without showing coverage of TCP edge cases.
domain assumption Few-shot prompted general-purpose LLMs are a fair comparison baseline; a pure SFT LLM without ALU was not tested.
Table V and Fig. 2 compare against few-shot baselines only, so the benefit of SFT and the benefit of the ALU are confounded.
ad hoc to paper The dual-agent simulator faithfully implements TCP interaction semantics without a real network stack.
Section IV-D validates on a closed framework built by the authors; no comparison against a real TCP stack or kernel implementation.

invented entities (2)

Smart-TCP agent (LLM cognitive core + ALU tool + state module) no independent evidence
purpose: Reimplements TCP control logic as an LLM-driven decision process with deterministic arithmetic tool.
No implementation is released and no external benchmark outside the paper's own simulator is provided; the agent has no falsifiable handle independent of the authors' evaluation.
Feature-aware classifier with SLM fast path / LLM slow path (as described in metadata abstract) no independent evidence
purpose: Routes routine segments to a lightweight SLM and anomalous/boundary cases to an LLM.
Appears only in the metadata abstract; the full text describes an LLM+ALU dual-agent architecture and gives no implementation or evaluation of fast/slow routing.

pith-pipeline@v1.3.0-alltime-deepseek · 7808 in / 13215 out tokens · 139489 ms · 2026-08-03T19:24:58.036118+00:00 · methodology

0 comments

Cite this review

Pith. "Pith review of Smart-TCP: An Agentic AI-based Autonomous and Adaptive TCP Protocol." pith.science (2026). https://pith.science/paper/7F7NYI62

@misc{pith2026251200491,
  author       = {Pith},
  title        = {Pith review of: Smart-TCP: An Agentic AI-based Autonomous and Adaptive TCP Protocol},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7F7NYI62}},
  note         = {Machine review of arXiv:2512.00491}
}

Share X Bluesky LinkedIn Reddit HN

read the original abstract

The Transmission Control Protocol (TCP) relies on deterministic state machines and sequence-number arithmetic to ensure reliable communication. However, hard-coded protocol logic is difficult to adapt to increasingly complex and dynamic network conditions. This paper proposes Smart-TCP, an agentic AI-based transport protocol framework that organizes TCP control logic as a fast/slow model-assisted decision process. Specifically, a feature-aware classifier routes routine segments to a lightweight Small Language Model (SLM) fast path and anomalous or boundary cases to a Large Language Model (LLM) slow path, while an Arithmetic Logic Unit (ALU) handles deterministic sequence- and acknowledgement-number computation. A state module maintains connection state, packet history, and key control variables, enabling protocol decisions over the full session context. We evaluate Smart-TCP through path classification, atomic packet processing, slow-path anomaly response, and end-to-end session interaction. Experimental results show that Smart-TCP achieves 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. These results suggest that decoupling model-based protocol reasoning from deterministic arithmetic improves the reliability of model-driven TCP control for network service operation.

Figures

Figures reproduced from arXiv: 2512.00491 by Kezhi Wang, Kun Yang, Yizhe Zhao, Yule Han.

**Figure 2.** Figure 2: Fine-Grained Field-Level Accuracy Qwen2.5, and Gemma models. These baseline models utilize few-shot prompting primarily to constrain the output format. They rely on their pre-trained knowledge to deduce the protocol logic and arithmetic operations. As shown in [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

discussion (0)

Reference graph

Works this paper leans on

9 extracted references · 2 linked inside Pith

[1]

Rfc 9293: Transmission control protocol (tcp),

W. Eddy, “Rfc 9293: Transmission control protocol (tcp),” 2022

2022
[2]

Large language models for next-generation wireless network management: A survey and tutorial,

B. Wei, R. Jiang, R. Zhang, Y . Liu, D. Niyato, Y . Sun, Y . Lu, Y . Li, S. Mao, C. Y uen et al. , “Large language models for next-generation wireless network management: A survey and tutorial,” arXiv preprint arXiv:2509.05946, 2025. 6

Pith/arXiv arXiv 2025
[3]

Netllm: Adapting large language models for networking,

D. Wu, X. Wang, Y . Qiao, Z. Wang, J. Jiang, S. Cui, and F. Wang, “Netllm: Adapting large language models for networking,” in Proceedings of the ACM SIGCOMM 2024 Conference . New Y ork, NY , USA: Association for Computing Machinery, 2024, p. 661678

2024
[4]

Unleashing the power of llm to infer state machine from the protocol implementation,

H. Wei, L. Chen, Z. Du, Y . Wu, H. Huang, Y . Liu, G. Cheng, F. Xu, L. Wang, and B. Mao, “Unleashing the power of llm to infer state machine from the protocol implementation,” 2025 IEEE/ACM 33rd International Symposium on Quality of Service (IWQoS) , pp. 1–10, 2024

2025
[5]

{PCC}: Re- architecting congestion control for consistent high performance,

M. Dong, Q. Li, D. Zarchy, P . B. Godfrey, and M. Schapira, “ {PCC}: Re- architecting congestion control for consistent high performance,” in 12th USENIX Symposium on Networked Systems Design and Implementation (NSDI 15) , 2015, pp. 395–408

2015
[6]

Tcp ex machina: Computer-generated congestion control,

K. Winstein and H. Balakrishnan, “Tcp ex machina: Computer-generated congestion control,” ACM SIGCOMM Computer Communication Review , vol. 43, no. 4, pp. 123–134, 2013

2013
[7]

Beyond pipelines: A survey of the paradigm shift toward model-native agentic ai,

J. Sang, J. Xiao, J. Han, J. Chen, X. Chen, S. Wei, Y . Sun, and Y . Wang, “Beyond pipelines: A survey of the paradigm shift toward model-native agentic ai,” arXiv preprint arXiv:2510.16720 , 2025

arXiv 2025
[8]

The lookahead lim- itation: Why multi-operand addition is hard for llms,

T. Baeumel, J. van Genabith, and S. Ostermann, “The lookahead lim- itation: Why multi-operand addition is hard for llms,” arXiv preprint arXiv:2502.19981, 2025

Pith/arXiv arXiv 2025
[9]

Characterization of encrypted and vpn trafﬁc using time-related,

G. Draper-Gil, A. H. Lashkari, M. S. I. Mamun, and A. A. Ghorbani, “Characterization of encrypted and vpn trafﬁc using time-related,” in Proceedings of the 2nd international conference on information systems security and privacy (ICISSP) , 2016, pp. 407–414

2016

[1] [1]

Rfc 9293: Transmission control protocol (tcp),

W. Eddy, “Rfc 9293: Transmission control protocol (tcp),” 2022

2022

[2] [2]

Large language models for next-generation wireless network management: A survey and tutorial,

B. Wei, R. Jiang, R. Zhang, Y . Liu, D. Niyato, Y . Sun, Y . Lu, Y . Li, S. Mao, C. Y uen et al. , “Large language models for next-generation wireless network management: A survey and tutorial,” arXiv preprint arXiv:2509.05946, 2025. 6

Pith/arXiv arXiv 2025

[3] [3]

Netllm: Adapting large language models for networking,

D. Wu, X. Wang, Y . Qiao, Z. Wang, J. Jiang, S. Cui, and F. Wang, “Netllm: Adapting large language models for networking,” in Proceedings of the ACM SIGCOMM 2024 Conference . New Y ork, NY , USA: Association for Computing Machinery, 2024, p. 661678

2024

[4] [4]

Unleashing the power of llm to infer state machine from the protocol implementation,

H. Wei, L. Chen, Z. Du, Y . Wu, H. Huang, Y . Liu, G. Cheng, F. Xu, L. Wang, and B. Mao, “Unleashing the power of llm to infer state machine from the protocol implementation,” 2025 IEEE/ACM 33rd International Symposium on Quality of Service (IWQoS) , pp. 1–10, 2024

2025

[5] [5]

{PCC}: Re- architecting congestion control for consistent high performance,

M. Dong, Q. Li, D. Zarchy, P . B. Godfrey, and M. Schapira, “ {PCC}: Re- architecting congestion control for consistent high performance,” in 12th USENIX Symposium on Networked Systems Design and Implementation (NSDI 15) , 2015, pp. 395–408

2015

[6] [6]

Tcp ex machina: Computer-generated congestion control,

K. Winstein and H. Balakrishnan, “Tcp ex machina: Computer-generated congestion control,” ACM SIGCOMM Computer Communication Review , vol. 43, no. 4, pp. 123–134, 2013

2013

[7] [7]

Beyond pipelines: A survey of the paradigm shift toward model-native agentic ai,

J. Sang, J. Xiao, J. Han, J. Chen, X. Chen, S. Wei, Y . Sun, and Y . Wang, “Beyond pipelines: A survey of the paradigm shift toward model-native agentic ai,” arXiv preprint arXiv:2510.16720 , 2025

arXiv 2025

[8] [8]

The lookahead lim- itation: Why multi-operand addition is hard for llms,

T. Baeumel, J. van Genabith, and S. Ostermann, “The lookahead lim- itation: Why multi-operand addition is hard for llms,” arXiv preprint arXiv:2502.19981, 2025

Pith/arXiv arXiv 2025

[9] [9]

Characterization of encrypted and vpn trafﬁc using time-related,

G. Draper-Gil, A. H. Lashkari, M. S. I. Mamun, and A. A. Ghorbani, “Characterization of encrypted and vpn trafﬁc using time-related,” in Proceedings of the 2nd international conference on information systems security and privacy (ICISSP) , 2016, pp. 407–414

2016

Smart-TCP: An Agentic AI-based Autonomous and Adaptive TCP Protocol

Core claim §

What carries the argument

Load-bearing premise §

What would settle it §

If this is right

Where Pith is reading between the lines

discussion (0)

Core claim

Load-bearing premise

What would settle it