Searcharxiv⌕ Search

arXiv subjects

Soheil Abbasloo

Publications and source records attributed to Soheil Abbasloo.

At least 19 recordsLinked to original sources

Benchmarks Don't Talk Back: Learning Through Self-Disagreement

A benchmark usually measures a language model alone with a question, and deployment rarely looks like that: answers get contested, and models give up correct ones under counter-reasoning that is itself wrong. We show that what fails there is not a shortfall of accuracy but a capability in its own right -- knowing when to hold a position and when to yield to a better one -- which we call dialectical competence. It stands on first-answer accuracy without following from it: a model can be made materially better at answering and no better at this, and training for accuracy alone can drift against it. Nor can it be bought at inference, by self-reflection or by sampling more. Taking a cue from the dialectical tradition in philosophy, in which productive opposition arises within a position rather than being imposed on it from outside, we hypothesize that this capability can be trained from opposition the model supplies itself. It states a position, generates the strongest case against that position -- its antithesis -- rules on whether the case stands, and is trained on that ruling, with no second model at training or at deployment. We call this learning through Self-Disagreement: reinforcement learning from verifiable rewards throughout, where the same check that scores an answer against its reference scores the ruling too, so no reward model, no preference data and no human annotation enter anywhere. The capability is trained rather than elicited: weak in the base model, it arrives with the reward, is not paid for out of first-answer accuracy, and holds against challengers the model never trained against, including ones stronger than itself. The opposition a model needs in order to improve, it turns out, need not come from outside it.

cs.CL↗

SIRIS: Can LLMs Tell When Simulation Errors Matter in AI-Driven Systems Research

LLM agents increasingly drive systems research and rely on simulators to evaluate candidate designs at scale. Simulators are imperfect by design: their modeling limitations can distort predictions yet leave the recommended design correct, or change which design should be selected. We introduce Siris to test whether LLMs can tell these cases apart, judging from their systems understanding when a limitation invalidates the simulator's recommendation. By perturbing a simulator, Siris constructs workload pairs with the same candidates, limitation, and simulator recommendation. The perturbation changes predictions on both workloads, yet a reference simulator supports the recommendation on only one. Evaluating thirteen frontier LLMs on LLM serving design problems, we find that identifying a limitation does not ensure a correct choice, and even the strongest models sometimes abandon valid recommendations. Self-correction through a review turn helps these models restore valid choices but introduces new errors in several others. These findings motivate evaluating systems understanding through design decisions under imperfect simulators.

cs.AI↗

Bias Control and Injection for Multi-Agent Aggregation

Multi-agent reasoning with large language models (LLMs) raises a central question for collective decision-making: when agents disagree, whose decision should be trusted? Resolving such disagreements is difficult because agents' decisions are susceptible to non-semantic biases such as majority pressure and response-style preferences, which can obscure the quality of the underlying reasoning. Our analysis shows how bias can be both mitigated and exploited: bias control improves initial answer selection, while bias injection elicits decision instability that serves as a reliability signal. Building on these findings, we introduce a test-time aggregation framework that requires neither validation data nor prior knowledge of relative model strength. The framework implements bias control by presenting one style-normalized reasoning trace per distinct answer, and bias injection by placing each aggregating agent's initially selected answer in the minority. Overall, our framework achieves higher average accuracy and better token efficiency than competing non-oracle aggregation methods across three mathematical reasoning benchmarks and four heterogeneous LLM combinations. It also improves final-answer accuracy when applied to multi-agent debate and Mixture-of-Agents, without modifying their interaction or synthesis processes.

cs.AI↗

Dynamic Expert Pruning for Multi-Agent Systems

Mixture-of-Experts (MoE) architectures scale language models efficiently by activating only a few experts per token, but the saving is confined to computation: every expert must stay resident on the accelerator, so memory bounds where these models can be deployed. Expert pruning reduces this footprint, yet existing methods are static --- a single mask, calibrated offline, is applied to the model for every subsequent request. This assumption can fail when the workload is heterogeneous, most prominently in multi-agent systems, where one backbone serves many tasks and roles at once: our analysis shows that different tasks and roles recruit different experts, while static methods assign one fixed subset to all of them. We therefore propose Dynamic Expert Pruning (DEP), which rests on a finding we establish here: an agent's system and task prompts are by themselves sufficient to identify the experts that agent and its task require, since that text already describes what the agent will do. A lightweight predictor, trained once on workflow transcripts, turns those prompts into a specialized per-request mask in a single forward pass, with no per-configuration calibration. Across diverse tasks and roles, model scales, and MoE architectures, DEP achieves better overall accuracy than static pruning and merging baselines, and generalizes to workflows unseen in training without retraining. Its margin over those baselines is largest when few experts are retained, suggesting that the role specialization inherent to multi-agent systems permits sparser serving than static pruning allows.

cs.LG↗

Do AI Agents Understand Computer Architecture?

Agents are increasingly asked to design hardware, and increasingly reported to succeed. Such reports establish that a design improved; they cannot establish why. An agent that improves an accelerator may be reasoning about the machine, or may be searching competently over knobs whose meaning it never recovers -- and only the first transfers to the next architecture. Existing evaluations cannot tell the two apart, because they vary the agent while holding the framing of the problem fixed. We do the opposite. AutoTuring hands the same agent the same 15-dimensional accelerator space twice: once as named architectural knobs with simulator counters, once as anonymous variables on [0,1], with the evaluator, the legal space and the reachable optima held identical, so that the only thing that varies is whether the problem means anything. The gap between the two is the measurement. On a nine-kernel FP16 GEMM basket, meaning pays: the architect beats a modeled H200 by 5.4% and its blind counterpart by 12.3% on average, with 70.1% fewer simulator calls. It does not pay uniquely: a critic loop recovers most of that gap for the blind agent and buys the architect nothing, so architectural knowledge and structured critique behave as substitutes rather than as complements. We report these as preliminary findings -- five to six runs per condition on a single modeled accelerator -- and take the comparison itself, not the accelerator, to be the contribution.

cs.AI↗

CornerCase: Automated Extremal Testing of Protocol Implementations using LLMs

Many software bugs in network protocol implementations arise near specification boundaries, such as inputs just within or outside allowed ranges, or messages that are valid in isolation but invalid in a given state. From the SSL Heartbleed exploit to TCP Christmas Tree packets, boundary inputs have repeatedly exposed critical weaknesses, yet remain under-tested by existing techniques such as fuzzing and model-based testing. We present CornerCase, an automated extremal testing approach that systematically targets such boundary behaviors. Our key idea is to decompose test generation into two stages: first, large language models (LLMs) extract explicit validity constraints from protocol specifications (e.g., RFCs) in a structured, section-by-section manner; second, extremal test cases are generated at or near the boundary of each constraint. These tests are executed across multiple implementations, and differential testing identifies inconsistencies. We evaluate CornerCase on widely used implementations of HTTP, DNS, BGP, SMTP, and QUIC, uncovering many previously unknown bugs. For example, the HTTP server h2o enters a redirect loop when processing URLs containing encoded null bytes. Overall, we used CornerCase to identify and file 42 anomalies; to date 26 have been acknowledged as bugs and 18 fixed, with others under active investigation

cs.NI↗

Evaluating LLM Reasoning Beyond Correctness and CoT

What does it truly mean for a language model to "reason"? Current evaluations reward models' correct standalone answers-but correctness alone reveals little about the process that produced them. We argue that reasoning should be understood not as a static chain of steps but as a dynamic trajectory in which ideas interact, clash, and evolve into integrated insights. Building on the philosophical tradition of dialectics, we introduce SIEV, a structured evaluation framework that assesses reasoning through explicit thesis-antithesis-synthesis interactions. SIEV produces interpretable trajectories that highlight key properties of reasoning-robustness to challenge, adaptability under conflict, and synthesis across competing viewpoints-dimensions that conventional correctness-based metrics cannot capture. Empirical results on GSM and MMLU demonstrate substantial gaps in the reasoning abilities of state-of-the-art models: for example, GPT-5-chat loses more than 40 points (out of 100) on GSM when evaluated through SIEV's process-oriented lens. By shifting focus from what answer a model gives to how it arrives there, SIEV enables a more transparent and principled distinction between structured reasoning and surface-level pattern generation offering a clearer foundation for assessing and understanding the reasoning capabilities of LLMs.

cs.AI↗

Beyond Correctness: Learning Robust Reasoning via Transfer

Reinforcement Learning with Verifiable Rewards (RLVR) has recently strengthened LLM reasoning, but its focus on final answer correctness leaves a critical gap: it does not ensure the robustness of the reasoning process itself. We adopt a simple philosophical view, robust reasoning should remain useful beyond the mind that produced it, and treat reasoning as a form of meaning transfer that must survive truncation, reinterpretation, and continuation. Building on this principle, we introduce Reinforcement Learning with Transferable Reward (RLTR), which operationalizes robustness via transfer reward that tests whether a partial reasoning prefix from one model can guide a separate model to the correct answer. This encourages LLMs to produce reasoning that is stable, interpretable, and genuinely generalizable. Our approach improves sampling consistency while improving final answer accuracy, and it reaches comparable performance in substantially fewer training steps. For example, on MATH500, RLTR achieves a +3.6%p gain in Maj@64 compared to RLVR and matches RLVR's average accuracy with roughly 2.5x fewer training steps, providing both more reliable reasoning and significantly more sample efficient.

cs.LG↗

Are Language Models Up to Sequential Optimization Problems? From Evaluation to a Hegelian-Inspired Enhancement

Large Language Models (LLMs) have demonstrated impressive capabilities across numerous fields, presenting an opportunity to revolutionize optimization problem-solving, a crucial, ubiquitous, and complex domain. This paper explores the proficiency of LLMs in handling Sequential Optimization Problems (SOPs). We introduce WorldGen, a dynamic framework for generating unseen SOPs with controllable complexities, to evaluate LLM performance. Our initial observations reveal that while LLMs perform well on simple SOPs, their performance significantly degrades with increased complexity. Motivated by this, we revisit philosophical hypotheses on reasoning to enhance LLM performance. Inspired by the influential framework of Hegelian Dialectics, we propose ACE, demonstrating how the performance of LLMs in SOP contexts can be significantly improved without any retraining or further fine-tuning.

cs.CL↗

A Simple Non-Deterministic Approach Can Adapt to Complex Unpredictable 5G Cellular Networks

5G cellular networks are envisioned to support a wide range of emerging delay-oriented services with different delay requirements (e.g., 20ms for VR/AR, 40ms for cloud gaming, and 100ms for immersive video streaming). However, due to the highly variable and unpredictable nature of 5G access links, existing end-to-end (e2e) congestion control (CC) schemes perform poorly for them. In this paper, we demonstrate that properly blending non-deterministic exploration techniques with straightforward proactive and reactive measures is sufficient to design a simple yet effective e2e CC scheme for 5G networks that can: (1) achieve high controllable performance, and (2) possess provable properties. To that end, we designed Reminis and through extensive experiments on emulated and real-world 5G networks, show the performance benefits of it compared with different CC schemes. For instance, averaged over 60 different 5G cellular links on the Standalone (SA) scenarios, compared with a recent design by Google (BBR2), Reminis can achieve 2.2x lower 95th percentile delay while having the same link utilization.

cs.NI↗

Internet Congestion Control Benchmarking

How do we assess a new Internet congestion control (CC) design? How do we compare it with other existing schemes? Under what scenarios and using what network parameters? These are just a handful of simple questions coming up every time a new CC design is going to be evaluated. Interestingly, the number of specific answers to these questions can be as large as the number of CC designers. In this work, we aim to highlight that the network congestion control, as a hot and active research topic, requires a crystal clear set(s) of \textit{CC Benchmarks} to form a common ground for quantitatively comparing and unambiguously assessing the strengths and weaknesses of a design with respect to the existing ones. As a first step toward that goal, we introduce general benchmarks that can capture the different performance of the existing Internet CC schemes. Using these benchmarks, we rank the Internet CC algorithms and illustrate that there is still lots of room for more innovations and improvements in this topic.

cs.NI↗

SharpEdge: An Asynchronous and Core-Agnostic Solution to Guarantee Bounded-Delays

What are the key properties that a network should have to provide bounded-delay guarantees for the packets? In this paper, we attempt to answer this question. To that end, we explore the theory of bounded-delay networks and provide the necessary and the sufficient conditions required to have deterministic bounded-delays in the network. We prove that as long as a network is work-conserving, independent of the packet scheduling and queue management algorithms used in the switches, it is sufficient to shape the traffic~\textit{properly} at the edge of the network to meet hard bounded-delays in the network. Using the derived theorems, we present SharpEdge, a novel design to meet deterministic bounded-delays in the network. To the best of our knowledge, SharpEdge is the first scheme that can meet all following key properties: 1) it supports coexistence of different classes of traffic, while it can guarantee their different required bounded-delays 2) it does not require any changes in the core of the network, 3) it supports both periodic and bursty traffic patterns, and 4) it does not require any time synchronization between network devices.

cs.NI↗

Wanna Make Your TCP Scheme Great for Cellular Networks? Let Machines Do It for You!

Can we instead of designing just another new TCP, design a TCP \textit{plug-in} which can boost the performance of the existing/future TCP designs in cellular networks? To answer this question, we introduce DeepCC plug-in. DeepCC leverages deep reinforcement learning (DRL), a modern decision-making tool, to steer TCP toward achieving applications' desired delay and high throughput in a highly dynamic network such as the cellular network. The fact that DeepCC does not try to reinvent/replace TCP but aims to boost the performance of it differentiates it from the most (if not all) of the existing reinforcement learning (RL) systems where RL systems are considered clean-slate alternative designs replacing the traditional ones. We used DeepCC plug-in to boost the performance of various old and new TCP schemes including TCP Cubic, Google's BBR, TCP Westwood, and TCP Illinois in cellular networks. Through both extensive trace-based evaluations and in-field tests, we show that not only DeepCC can significantly improve the performance of TCP, but also after accompanied by DeepCC, these schemes can outperform state-of-the-art TCP protocols including Aurora, Sprout, Verus, C2TCP, Copa, Indigo, Remy, PCC-Vivace, and LEDBAT in cellular networks.

cs.NI↗

To schedule or not to schedule: when no-scheduling can beat the best-known flow scheduling algorithm in datacenter networks

Conventional wisdom for minimizing the average flow completion time (AFCT) in the datacenter network (DCN), where flow sizes are highly variable, would suggest scheduling every individual flow. However, we show that considering scheduling delay (including scheduler's computational and communication delays), serving most of the flows without any scheduling and only in first-come-first-served (FCFS) manner significantly improves their performance even when it is compared to the shortest remaining processing time (SRPT)-known as optimum algorithm when scheduling delay is zero. To do so, we only require to have two coarse classes of flows categorized based on flows' sizes (1st-class including flows smaller than a threshold, H, and 2nd-class including others) and serve 1st-class flows always before serving 2nd-class ones. To show that, we take SRPT scheduling algorithm accompanied by the global knowledge of flows, formulate impact of scheduling delay on its performance, and prove that for any flow size distribution and network load (<1), there is always a threshold, H, which guarantees 1st-class flows achieve lower AFCT under FCFS compared to SRPT. Our numerically calculated results and extensive flow-level simulations show that on average, more than 90% of flows could be in 1st-class and consequently do not require any scheduling.

cs.NI↗

Bounding Queue Delay in Cellular Networks to Support Ultra-Low Latency Applications

Most of the current active queue management (AQM) designs have major issues including severe hardship of being tuned for highly fluctuated cellular access link bandwidths. Consequently, most of the cellular network providers either give up using AQMs or use conservative offline configurations for them. However, these choices will significantly impact the performance of the emerging interactive and highly delay sensitive applications such as virtual reality and vehicle-to-vehicle communications. Therefore, in this paper, we investigate the problems of existing AQM schemes and show that they are not suitable options to support ultra-low latency applications in a highly dynamic network such as current and future cellular networks. Moreover, we believe that achieving good performance does not necessarily come from complex drop rate calculation algorithms or complicated AQM techniques. Consequently, we propose BoDe an extremely simple and deployment friendly AQM scheme to bound the queuing delay of served packets and support ultra-low latency applications. We have evaluated BoDe in extensive trace-based evaluations using cellular traces from 3 different service providers in the US and compared its performance with state-of-the-art AQM designs including CoDel and PIE under a variety of streaming applications, video conferencing applications, and various recently proposed TCP protocols. Results show that despite BoDe's simple design, it outperforms other schemes and achieves significantly lower queuing delay in all tested scenarios.

cs.NI↗

Toward Optimal Performance with Network Assisted TCP at Mobile Edge

In contrast to the classic fashion for designing distributed end-to-end (e2e) TCP schemes for cellular networks (CN), we explore another design space by having the CN assist the task of the transport control. We show that in the emerging cellular architectures such as mobile/multi-access edge computing (MEC), where the servers are located close to the radio access network (RAN), significant improvements can be achieved by leveraging the nature of the logically centralized network measurements at the RAN and passing information such as its minimum e2e delay and access link capacity to each server. Particularly, a Network Assistance module (located at the mobile edge) will pair up with wireless scheduler to provide feedback information to each server and facilitate the task of congestion control. To that end, we present two Network Assisted schemes called NATCP (a clean-slate design replacing TCP at end-hosts) and NACubic (a backward compatible design requiring no change for TCP at end-hosts). Our preliminary evaluations using real cellular traces show that both schemes dramatically outperform existing schemes both in single-flow and multi-flow scenarios.

cs.NI↗

C2TCP: A Flexible Cellular TCP to Meet Stringent Delay Requirements

Since current widely available network protocols/systems are mainly throughput-oriented designs, meeting stringent delay requirements of new applications such as virtual reality and vehicle-to-vehicle communications on cellular network requires new network protocol/system designs. C2TCP is an effort toward that new design direction. C2TCP is inspired by in-network active queue management (AQM) designs such as RED and CoDel and motivated by lack of a flexible end-to-end (e2e) approach which can adapt itself to different applications' QoS requirements without modifying any network devices. It copes with unique challenges in cellular networks for achieving ultra-low latency (including highly variable channels, deep per-user buffers, self-inflicted queuing delays, radio uplink/downlink scheduling delays) and intends to satisfy stringent delay requirements of different applications while maximizing the throughput. C2TCP works on top of classic throughput-oriented TCP and accommodates various target delays without requiring any channel prediction, network state profiling, or complicated rate adjustment mechanisms. We have evaluated C2TCP in both real-world environment and extensive trace-based emulations and compared its performance with different TCP variants and state-of-the-art schemes including PCC-Vivace, Google's BBR, Verus, Sprout, TCP Westwood, and Cubic. Results show that C2TCP outperforms all these schemes and achieves lower average delay, jitter, and 95th percentile delay for packets.

cs.NI↗

HyLine: a Simple and Practical Flow Scheduling for Commodity Datacenters

Today's datacenter networks (DCNs) have been built upon multipath topologies where each path contains multiple links. However, flow scheduling schemes proposed to minimize flow completion times (FCT) in DCNs are based on algorithms which are optimum or close-to-optimum only over single link. Moreover, most of these scheduling schemes seek either fully centralized approaches having overhead of communicating to a central entity or fully distributed approaches requiring changes in the fabric. Motivated by these shortcomings, we present HyLine a simple scheduling design for commodity DCNs which is equipped with a joint load-balancing and flow scheduling (path-aware) design exploiting the multipath nature of DCNs. HyLine takes a hybrid approach and uses the global-awareness of centralized and agility of distributed techniques without requiring any changes in the fabric. To that end, it determines a threshold margin identifying flows for which using centralized approach is beneficial. We have shown through extensive ns2 simulations that despite HyLine's simplicity, it significantly outperforms existing schemes and achieves lower average and 99th percentile FCTs. For instance, compared to Qjump-state-of-the-art practical scheme-and pFabric-one of the best performing flow scheduling schemes-HyLine reduces average FCT up to 68% and 31%, respectively, under a production datacenter workload.

cs.NI↗