Numeric Self-Report Metrics

Updated 3 July 2026

Numeric self-report is a paradigm that quantifies system performance by assigning a scalar value reflecting offloading, energy use, delay, and cognitive effort.
These metrics are constructed using counterfactual simulations, queueing models, and aggregated observables, allowing customization to domain-specific constraints in computing and networking.
Numeric self-report metrics enable optimization, monitoring, and adaptive decision-making in systems such as edge computing and human-AI workflows, ensuring robustness and sensitivity.

Numeric self-report refers to the class of quantitative, algorithmic, and process-oriented metrics that assign real-valued scores to describe, evaluate, or control offloading and delegation in computing, networking, and human-AI collaboration contexts. These scores synthesize multiple observables (latency, energy, accuracy, cost, cognitive effort, or process steps) into a single scalar output used in optimization, monitoring, or policy selection. The numeric self-report paradigm appears across domains: offloading in edge/cloud computing, assignment in networking, trust and reputation systems, and—in the human–AI ecosystem—process-tracing of cognitive effort delegation. While the metrics share this reporting and normalization function, the exact construction, theoretical grounding, operational semantics, and usage depend on the system context and domain constraints.

1. Formal Definitions and Metric Construction

Numeric self-report metrics are mathematically defined scalars designed to encapsulate complex, multidimensional phenomena—such as resource utilization, system capacity, workflow effort, or reliability—into a single interpretable value. These formulations are tightly coupled to the system's model of operation.

A paradigmatic example from human–AI collaboration is the Offloading Score (OS), which quantifies reliance on AI tools by modeling the fraction of workflow steps delegated to the tool. Given a workflow $W = \{w_1, \ldots, w_n\}$ composed of $n$ steps, OS is constructed by:

Identifying AI-assisted steps and simulating, for each, a counterfactual human-only sequence $w'_i = \{w'_{i,1},\ldots,w'_{i,k_i}\}$ .
Calculating total counterfactual workflow length $m = \sum_{i=1}^n k_i$ .
Computing the normalized offloading score:

$\mathrm{OS} = \frac{m-n}{m} = 1 - \frac{n}{m}$

This measures the proportion of effort "saved" via delegation, with values in $[0,1]$ (Padmakumar et al., 28 May 2026).

In edge computing and wireless networking, numeric scores often combine expected bandwidth, handover rates, or delay probabilities. For instance, in femtocell LTE deployments, the Threshold Offloading (TO) "score" combines normalized reductions in signalling overhead ( $\Theta(t_o)$ ) and maintenance of femtocell offloading capacity ( $\Lambda(t_o)$ ) as $F(t_o) = \Theta(t_o) + \Lambda(t_o)$ (Chen et al., 2016).

Each metric is tightly coupled to the application's performance—e.g., mean Average Precision improvement for object detection (ORIC) (Qiu et al., 2024), queueing-theoretic latency differences for edge–client dispatch (Ng et al., 21 Apr 2025), or composite energy–delay–cost in cloud–edge task assignment (Jiang et al., 2018).

2. Domain-Specific Instantiations

The construction and interpretation of numeric self-report scores vary fundamentally by domain and target phenomenon.

2.1 Process-Oriented Cognitive Offloading

In the human-AI workflow context, numeric self-report enables behavioral quantification: OS reflects the "steps saved" by AI, constructed via counterfactual simulation using LLMs to model realistic human-alone workflows. Validation with human annotators and controlled studies confirms the score's sensitivity and criterion validity, surpassing output-adoption or subjective self-ratings in discriminating known reliance drivers such as time pressure (Padmakumar et al., 28 May 2026).

2.2 Edge Computing and Wireless Offload

In wireless networks, self-reporting metrics aggregate user-experienced throughput and mobility-induced penalties. In WLAN offload modeling, $S_{\mathrm{offload}} = w_1 B_s - w_2 E[N_h]$ balances normalized bandwidth gain against handover cost (Saito et al., 2014). In femtocell TO algorithms, $n$ 0 quantifies the trade-off between signaling overhead and offloading retention, providing both theoretical bounds and actionable operational thresholds (Chen et al., 2016).

In edge computing resource assignment, scalar scores (e.g., energy–delay–cost weighted sums) support centralized or distributed optimization. The "offloading cost" $n$ 1 compresses multi-modal objectives into one value per task–assignment, enabling algorithmic comparison and combinatorial assignment at scale (Jiang et al., 2018).

2.3 Trust, Reputation, and Online Decision-Making

Numeric self-report is central in reputation models for edge offloading. In FRESCO, server reputation $n$ 2 is recursively updated via exponential smoothing with instantaneous incentives $n$ 3 for deadline-compliance; this history-dependent scalar is then injected as a constraint and term into an SMT-based optimizer for offloading site selection (Zilic et al., 2024).

Probabilistic online decision algorithms (adversarial bandits for offloading) use cumulative estimated costs, patched and normalized by input size, as per-node scores to set Boltzmann-selection probabilities and adapt exploration–exploitation trade-off (Cho et al., 2021).

3. Model-Based, Counterfactual, and Simulation-Driven Scores

Simulating counterfactuals and process models is a hallmark of modern numeric self-report frameworks. The process-centric OS relies on LLMs to estimate human-only workflow length. In computational offloading, latency and resource–cost models are constructed from analytic queueing theory (e.g., M/D/1 or M/G/1 approximations, transmission rate formulas) and/or regression from historical data. These models predict scores under observed or hypothetical load, bandwidth, or system state (Ng et al., 21 Apr 2025, Crutcher et al., 2017).

Simulation-based approaches are validated experimentally. For example, predicted OffloadScore differences (local–edge) match observed switching points within 2.2% across real workloads (Ng et al., 21 Apr 2025).

4. Practical Use: Optimization, Monitoring, and Decision Mechanisms

Numeric self-report metrics are operationalized as reward functions, optimization objectives, or feasibility constraints.

Thresholding: Top- $n$ 4 ORIC scores indicate which images to offload under limited resource budgets (Qiu et al., 2024).
Greedy assignment or kNN minimization: Weighted distance in hyperprofile space guides server selection, metric choice (Euclidean/Manhattan) impacts trade-off (Crutcher et al., 2017).
Optimization: MDPs, multi-agent RL, or integer programming use offloading score as the reward to maximize, incorporating user or system preferences via weights (Chen et al., 2024, Jiang et al., 2018).
Real-time adaptation: Quantities such as reputation thresholds or score patching enable online systems to adapt to changing candidate sets or temporal load profiles (Zilic et al., 2024, Cho et al., 2021).

Common to these deployments is that the metric's algorithmic form is aligned with system priorities (latency, reliability, fairness, or energy/cost). The modularity of the approach allows integration of new observables (semantic factor, context sets, reliability signals).

5. Validation, Sensitivity, and Robustness

Validation of numeric self-report metrics leverages both theoretical reproducibility (e.g., closed-form match to simulation within 1% across load scenarios (Chen et al., 2016)) and empirical sensitivity measures (statistical significance in user studies for OS, Table 3/5 in (Padmakumar et al., 28 May 2026)). Robustness to input perturbations, domain parameterization, and segmentation errors are also documented.

In process-oriented OS, self-report is more sensitive to cognitive offloading manipulation ( $n$ 543% under time pressure, $n$ 6), with stability to LLM seed/model (Padmakumar et al., 28 May 2026).
Network offloading scores reflect fine-tuned operator priorities; changes in AP density or resource constraints predictably shift the score, as detailed in algorithmic tables and parametric sweeps [(Saito et al., 2014); (Jiang et al., 2018)].
Reputation-based scores respond to recent server events with a tunable smoothing parameter $n$ 7, balancing responsiveness against volatility (Zilic et al., 2024).

6. Limitations and Prospects

Numeric self-report metrics are constrained by the quality of underlying models (counterfactual workflow for OS, queueing assumptions, or regression for network/energy cost). Human-only process simulations are not fully personalized; step counts may not perfectly correspond to cognitive effort. In networking, score formulas omit interference, contention, or advanced mobility models. Algorithmic hyperparameters require tuning for application context and fairness/efficiency trade-off.

Prospective applications include real-time self-reflective indicators for end-users or agent designers (e.g., overreliance detection in AI collaboration), automated offloading in edge-cognitive systems, fairness monitoring, or benchmarking of novel system architectures (Padmakumar et al., 28 May 2026, Qiu et al., 2024, Zilic et al., 2024).

In summary, numeric self-report metrics provide a unifying, rigorous approach to quantifying offloading and delegation phenomena in both technical systems and human-machine workflows. Their mathematical construction, operational semantics, and validation approaches are rapidly evolving, with research emphasizing context-aware, process-oriented, and adaptive instantiations for reliable, interpretable, and effective system optimization and analysis.