Network Slice Tenants (NSTs) Overview

• Network Slice Tenants (NSTs) are logical entities, such as third-party enterprises or verticals, that lease and manage virtual network slices on shared 5G infrastructures.
• They specify service level agreements and dynamically interact with orchestration, admission control, and optimization frameworks to ensure scalable performance.
• NST models employ game-theoretic resource allocation, queue-based admission control, and blockchain smart contracts to maximize utility, fairness, and isolation.

A Network Slice Tenant (NST) is a logical entity—typically a third-party enterprise, vertical, or operator—that leases, acquires, or manages one or more virtual network slices instantiated atop a shared infrastructure. NSTs consume resources, specify service requirements (often formalized as SLAs), and may dynamically interact with resource orchestration, admission control, or optimization frameworks developed for 5G and beyond. NSTs are central actors in the multi-tenancy paradigms underpinning network slicing and are modeled explicitly within resource allocation games, brokerage systems, admission control schemes, and management architectures across both public and private network environments.

1. Structural Role and Definition of NSTs

NSTs are positioned as customers or lessees of virtualized network resources provided by mobile operators (MNOs), infrastructure providers (InPs), or intermediate brokers (IBs). In the SlaaS and NSaaS models, an NST typically initiates slice requests specifying resource requirements (e.g., bandwidth, latency, per-slice isolation). Upon admission, NSTs operate and consume the allocated network slice instance(s) either exclusively or in shared/multi-tenant modes, per the architectural model at hand (Zanzi et al., 2020, Han et al., 2017, Reyhanian et al., 2021, Vidal et al., 15 Jan 2026, Badmus et al., 2019, Tranoris, 2021, Ordonez-Lucena et al., 2018, Badmus et al., 2020).

For example, NSBchain explicitly defines an NST as "any third-party business entity—an over-the-top provider, industrial vertical or service-oriented enterprise—that leases a precisely tailored 'slice' of virtualized mobile network resources" via blockchain-governed smart contracts (Zanzi et al., 2020). Micro-operator models categorize NSTs into closed, open, and mixed tenants—accommodating both private verticals and public subscribers—mapped to different network slice instance (NSI) configuration types (Badmus et al., 2019).

2. Resource Allocation and Competitive Game Models

The core of many NST models is a strategic resource allocation game, often implemented as a share-constrained proportional allocation (SCPA) or Nash equilibrium over slice requests. Each NST is assigned (exogenously or via auction/negotiation) a global resource share $s_i$ and must decide how to distribute its share across multiple domains (for example, over radio access cells) using a vector of weights $\omega_i^{(j)}$, subject to $\sum_j \omega_i^{(j)} = s_i$ (Caballero et al., 2016, Guijarro et al., 2019, Vidal et al., 15 Jan 2026).

At equilibrium, the proportional division of cell capacity among NSTs is

$$R_i^{(j)} = \frac{\omega_i^{(j)}}{\sum_t \omega_t^{(j)}} c^{(j)}$$

and users select their NST based on utility maximization, frequently captured by a random-utility (logit) model (Vidal et al., 15 Jan 2026, Guijarro et al., 2019). The resulting market shares and subscription ratios for each NST are given in closed form in homogeneous scenarios and approximate NE in heterogeneous settings.

Model	NST Strategy/Decision Variable	Key Equilibrium Expression
SCPA (Caballero et al., 2016)	Per-user weights under per-tenant share	Nash equilibrium in joint user/slice allocation
Logit/Resource Game (Vidal et al., 15 Jan 2026, Guijarro et al., 2019)	Weight vector $\omega_i^{(j)}$ over domains	$$\rho_i^{(j)} = \frac{(\omega_i^{(j)})^\beta}{\sum_t (\omega_t^{(j)})^\beta}$$

NSTs in these models act non-cooperatively, maximizing their subscriber pools or net utility, and the resulting games admit both exact and approximate closed-form expressions for resource, user, and profit allocations under broad regularity conditions (Guijarro et al., 2019, Vidal et al., 15 Jan 2026).

3. Admission Control, Elasticity, and Multi-Queue Models

NST requests are typically subject to provider-side admission control dictated by resource state and profit-maximizing policies. The models in (Han et al., 2019, Han et al., 2017, Ebrahimi et al., 2019, Batista et al., 2019) formalize NST requests as tuples encompassing processing, storage, link, and slice lifetime/resource class—often augmented with priority or elasticity requirements.

In multi-queue orchestration (e.g., (Han et al., 2019)), NSTs generate Poisson arrival streams (one per slice type), with admissions controlled via a heterogeneous queueing system. Rational NSTs may exhibit impatience—balking or reneging—based on profit and waiting cost models: $$\text{Balk if}~\zeta \tau - u_0 - u\,\mathbb{E}[W(l)] < 0$$ where $\zeta$ is per-time profit upon acceptance, $\tau$ expected active lifetime, and $u_0, u$ fixed and per-unit waiting costs.

The utility-optimal admission policy is threshold-based and may be computed via dynamic programming or reinforcement learning (RL) (Han et al., 2017, Batista et al., 2019), with joint optimization over admission and embedding (placement) variables (Ebrahimi et al., 2019). For joint resource and admission management, MILP and scalable heuristics admit significantly more NSTs at lower overall cost than disjoint schemes, with explicit embedding and bandwidth/delay constraints for VM and VL instantiations.

4. Management, Brokerage, and Control Plane Architectures

Network management architectures implement NST operations using layered functional models. In NSBchain (Zanzi et al., 2020), NSTs communicate resource requests via signed smart contract invocations, triggering blockchain-coordinated audit, billing, and state transitions. Allocation decisions are solved via integer-linear programs maximizing broker revenue under capacity constraints, with high-throughput, low-latency confirmation via permissioned consensus.

3GPP-aligned OSS platforms such as OpenSlice (Tranoris, 2021) model NSTs as customers (NSCs) authenticated via party/info management (Keycloak, TMF 632), ordering slices over TMF standard APIs (TMF 633/641/638/640), and operating instances via OSOM orchestrators which coordinate lifecycle over REST and ETSI SOL005 interfaces. NSTs manage slices through well-defined API flows: discovery, ordering, fulfillment, and day-2 reconfiguration.

Multi-tenant orchestration in local 5G micro-operators (Badmus et al., 2019) utilizes CSMF/NSMF/NSSMF/NFMF stacks for mapping NST service requests into concrete slice (NSI) configurations of varying sharing/isolation (types 1–3), supporting closed, open, and mixed tenant groups.

Management Layer	Role for NST	Reference
CSMF	Ingest service requests, SLA	(Badmus et al., 2019, Badmus et al., 2020)
NSMF	End-to-end slice orchestration	(Badmus et al., 2019)
IB/Blockchain SC	Enforce allocation, audit	(Zanzi et al., 2020)
OSOM/TMF Orchestrator	Service order fulfillment	(Tranoris, 2021)

5. Utility, Overload, and Isolation Models

Economic and operational trade-offs for NSTs are quantified in terms of revenue, cost, utility, and resource isolation levels. Overbooking and risk-aware admission models are vital in highly multiplexed environments, where NSTs compete for finite underlying resources. An online estimator based on a queueing birth-death model and a truncated Gaussian mixture for per-slice load allows real-time estimation of the overload risk (probability that total resource usage by NST slices exceeds capacity), supporting dynamic tuning of the admission threshold to ensure SLA compliance (Hamad et al., 2021).

Resource isolation and elastic allocation appear both in optimization-oriented management schemes (e.g., (Reyhanian et al., 2021)), where two-timescale frameworks optimize both long-term tenant utility (subject to activation costs and resource constraints) and short-term adaptation to stochastic fluctuations, and in energy/throughput Pareto-efficient RAN slicing for NSTs (Matthiesen et al., 2018).

Analytical models provide explicit guidelines:

• NST isolation is guaranteed via per-slice resource partitioning or strict share constraints.
• Utility functions (often α-fair, log-concave, or piecewise-linear) underpin tenant–provider optimization, with unique and efficient NE under standard assumptions.
• Monitoring and control layers expose per-NST metrics and admit feedback control for maintaining performance and isolating faults or overloads.

6. Fairness, Privacy, and Market Mechanisms

Fairness, efficiency, and privacy are key design axes for NST-oriented slice orchestration. Standard SCPA and welfare-maximizing auction/market games (Caballero et al., 2016, Khamse-Ashari et al., 2021) guarantee that

• Each NST receives at least as much utility as under static partitioning (protection property).
• Global Nash equilibria are envy-free: no NST would prefer the allocation of another tenant scaled to its own share.
• The mechanism admits a bounded price of anarchy (at least 50% of global maximum utility under log utilities), with practical efficiency often above 90%.

Distributed market mechanisms enable tenants to remain privacy-preserving—submitting only scalar bids rather than revealing private utility or demand functions, and with providers publishing only resource prices—while guaranteeing convergence to the social optimum and providing sharing-incentive properties (tenants benefit from participating in multiplexed systems versus reserve-only partitions) (Khamse-Ashari et al., 2021). Blockchain-based approaches further reinforce auditability and immutability in resource assignment (Zanzi et al., 2020).

7. Design Guidelines and Practical Implications

Research across architectures and models produces convergent guidelines for deploying and managing NSTs:

• Enforce explicit per-NST resource shares or SLAs at admission to guarantee performance isolation.
• Enable NST-controlled flexible share allocation to exploit local traffic variations and achieve Pareto gains over static partitioning (up to 25% measured in typical cases (Caballero et al., 2016)).
• Use policy-based APIs and programmable weight, bandwidth, or VM assignments to facilitate NST-driven adaptation, within safe provider-imposed envelopes.
• Provide at least minimal queue state and performance information to NSTs; sharing queue position and acceptance rates markedly increases tenant utility and system efficiency (Han et al., 2019).
• Joint embedding and admission achieves higher system utilization and tenant acceptance rates than disjoint approaches.

In summary, the NST construct is foundational to multi-tenant network slicing, mediating economic, technical, and management interactions between infrastructure providers and diverse, service-oriented tenants. The theoretical models and architectural frameworks developed for NST management provide scalable, fair, and efficient solutions under rigorous, model-based foundations (Caballero et al., 2016, Guijarro et al., 2019, Vidal et al., 15 Jan 2026, Zanzi et al., 2020, Hamad et al., 2021, Han et al., 2017, Khamse-Ashari et al., 2021, Badmus et al., 2019, Ebrahimi et al., 2019, Tranoris, 2021, Ordonez-Lucena et al., 2018).