diff --git a/src/runtime/virtcontainers/kata_agent.go b/src/runtime/virtcontainers/kata_agent.go
index aa1d4968f2..bd7c04ed13 100644
--- a/src/runtime/virtcontainers/kata_agent.go
+++ b/src/runtime/virtcontainers/kata_agent.go
@@ -784,7 +784,7 @@ func (k *kataAgent) startSandbox(ctx context.Context, sandbox *Sandbox) error {
 	}
 
 	// Setup network interfaces and routes
-	interfaces, routes, neighs, err := generateVCNetworkStructures(ctx, sandbox.networkNS)
+	interfaces, routes, neighs, err := generateVCNetworkStructures(ctx, sandbox.network)
 	if err != nil {
 		return err
 	}
diff --git a/src/runtime/virtcontainers/network.go b/src/runtime/virtcontainers/network.go
index 1313e1bf8a..7e78d86cbe 100644
--- a/src/runtime/virtcontainers/network.go
+++ b/src/runtime/virtcontainers/network.go
@@ -26,6 +26,7 @@ import (
 
 	"github.com/kata-containers/kata-containers/src/runtime/pkg/katautils/katatrace"
 	"github.com/kata-containers/kata-containers/src/runtime/pkg/uuid"
+	persistapi "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/persist/api"
 	pbTypes "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/pkg/agent/protocols"
 	"github.com/kata-containers/kata-containers/src/runtime/virtcontainers/utils"
 )
@@ -220,6 +221,40 @@ func NewNetwork(configs ...*NetworkConfig) (*Network, error) {
 	}, nil
 }
 
+func LoadNetwork(netInfo persistapi.NetworkInfo) *Network {
+	network := &Network{
+		NetNSPath:    netInfo.NetNsPath,
+		NetNSCreated: netInfo.NetNsCreated,
+	}
+
+	for _, e := range netInfo.Endpoints {
+		var ep Endpoint
+		switch EndpointType(e.Type) {
+		case PhysicalEndpointType:
+			ep = &PhysicalEndpoint{}
+		case VethEndpointType:
+			ep = &VethEndpoint{}
+		case VhostUserEndpointType:
+			ep = &VhostUserEndpoint{}
+		case MacvlanEndpointType:
+			ep = &MacvlanEndpoint{}
+		case MacvtapEndpointType:
+			ep = &MacvtapEndpoint{}
+		case TapEndpointType:
+			ep = &TapEndpoint{}
+		case IPVlanEndpointType:
+			ep = &IPVlanEndpoint{}
+		default:
+			networkLogger().WithField("endpoint-type", e.Type).Error("unknown endpoint type")
+			continue
+		}
+		ep.load(e)
+		network.Endpoints = append(network.Endpoints, ep)
+	}
+
+	return network
+}
+
 var networkTrace = getNetworkTrace("")
 
 func (n *Network) trace(ctx context.Context, name string) (otelTrace.Span, context.Context) {
@@ -459,19 +494,19 @@ func (n *Network) Run(ctx context.Context, cb func() error) error {
 }
 
 // Add adds all needed interfaces inside the network namespace.
-func (n *Network) Add(ctx context.Context, s *Sandbox, hotplug bool) ([]Endpoint, error) {
+func (n *Network) Add(ctx context.Context, s *Sandbox, hotplug bool) error {
 	span, ctx := n.trace(ctx, "Add")
 	katatrace.AddTags(span, "type", n.InterworkingModel.GetModel())
 	defer span.End()
 
 	if err := n.attachEndpoints(ctx, s, hotplug); err != nil {
-		return n.Endpoints, err
+		return err
 	}
 
 	katatrace.AddTags(span, "endpoints", n.Endpoints, "hotplug", hotplug)
 	networkLogger().Debug("Network added")
 
-	return n.Endpoints, nil
+	return nil
 }
 
 func (n *Network) PostAdd(ctx context.Context, hotplug bool) error {
@@ -522,13 +557,6 @@ func (n *Network) Remove(ctx context.Context) error {
 	return nil
 }
 
-// NetworkNamespace contains all data related to its network namespace.
-type NetworkNamespace struct {
-	NetNsPath    string
-	Endpoints    []Endpoint
-	NetNsCreated bool
-}
-
 func createLink(netHandle *netlink.Handle, name string, expectedLink netlink.Link, queues int) (netlink.Link, []*os.File, error) {
 	var newLink netlink.Link
 	var fds []*os.File
@@ -1183,8 +1211,8 @@ func deleteNetNS(netNSPath string) error {
 	return nil
 }
 
-func generateVCNetworkStructures(ctx context.Context, networkNS NetworkNamespace) ([]*pbTypes.Interface, []*pbTypes.Route, []*pbTypes.ARPNeighbor, error) {
-	if networkNS.NetNsPath == "" {
+func generateVCNetworkStructures(ctx context.Context, network *Network) ([]*pbTypes.Interface, []*pbTypes.Route, []*pbTypes.ARPNeighbor, error) {
+	if network.NetNSPath == "" {
 		return nil, nil, nil, nil
 	}
 	span, _ := networkTrace(ctx, "generateVCNetworkStructures", nil)
@@ -1194,7 +1222,7 @@ func generateVCNetworkStructures(ctx context.Context, networkNS NetworkNamespace
 	var ifaces []*pbTypes.Interface
 	var neighs []*pbTypes.ARPNeighbor
 
-	for _, endpoint := range networkNS.Endpoints {
+	for _, endpoint := range network.Endpoints {
 		var ipAddresses []*pbTypes.IPAddress
 		for _, addr := range endpoint.Properties().Addrs {
 			// Skip localhost interface
diff --git a/src/runtime/virtcontainers/network_test.go b/src/runtime/virtcontainers/network_test.go
index 2538caca0e..2a3f160b1d 100644
--- a/src/runtime/virtcontainers/network_test.go
+++ b/src/runtime/virtcontainers/network_test.go
@@ -73,7 +73,9 @@ func TestGenerateInterfacesAndRoutes(t *testing.T) {
 
 	endpoints := []Endpoint{ep0}
 
-	nns := NetworkNamespace{NetNsPath: "foobar", NetNsCreated: true, Endpoints: endpoints}
+	nns, err := NewNetwork(&NetworkConfig{NetNSPath: "foobar", NetNsCreated: true})
+	assert.Nil(t, err)
+	nns.Endpoints = endpoints
 
 	resInterfaces, resRoutes, resNeighs, err := generateVCNetworkStructures(context.Background(), nns)
 
diff --git a/src/runtime/virtcontainers/persist.go b/src/runtime/virtcontainers/persist.go
index c36a5bf3ee..cee218c51a 100644
--- a/src/runtime/virtcontainers/persist.go
+++ b/src/runtime/virtcontainers/persist.go
@@ -164,10 +164,10 @@ func (s *Sandbox) dumpAgent(ss *persistapi.SandboxState) {
 
 func (s *Sandbox) dumpNetwork(ss *persistapi.SandboxState) {
 	ss.Network = persistapi.NetworkInfo{
-		NetNsPath:    s.networkNS.NetNsPath,
-		NetNsCreated: s.networkNS.NetNsCreated,
+		NetNsPath:    s.network.NetNSPath,
+		NetNsCreated: s.network.NetNSCreated,
 	}
-	for _, e := range s.networkNS.Endpoints {
+	for _, e := range s.network.Endpoints {
 		ss.Network.Endpoints = append(ss.Network.Endpoints, e.save())
 	}
 }
@@ -363,35 +363,7 @@ func (c *Container) loadContProcess(cs persistapi.ContainerState) {
 }
 
 func (s *Sandbox) loadNetwork(netInfo persistapi.NetworkInfo) {
-	s.networkNS = NetworkNamespace{
-		NetNsPath:    netInfo.NetNsPath,
-		NetNsCreated: netInfo.NetNsCreated,
-	}
-
-	for _, e := range netInfo.Endpoints {
-		var ep Endpoint
-		switch EndpointType(e.Type) {
-		case PhysicalEndpointType:
-			ep = &PhysicalEndpoint{}
-		case VethEndpointType:
-			ep = &VethEndpoint{}
-		case VhostUserEndpointType:
-			ep = &VhostUserEndpoint{}
-		case MacvlanEndpointType:
-			ep = &MacvlanEndpoint{}
-		case MacvtapEndpointType:
-			ep = &MacvtapEndpoint{}
-		case TapEndpointType:
-			ep = &TapEndpoint{}
-		case IPVlanEndpointType:
-			ep = &IPVlanEndpoint{}
-		default:
-			s.Logger().WithField("endpoint-type", e.Type).Error("unknown endpoint type")
-			continue
-		}
-		ep.load(e)
-		s.networkNS.Endpoints = append(s.networkNS.Endpoints, ep)
-	}
+	s.network = LoadNetwork(netInfo)
 }
 
 // Restore will restore sandbox data from persist file on disk
diff --git a/src/runtime/virtcontainers/persist_test.go b/src/runtime/virtcontainers/persist_test.go
index b1a1ea68d3..228638a960 100644
--- a/src/runtime/virtcontainers/persist_test.go
+++ b/src/runtime/virtcontainers/persist_test.go
@@ -26,11 +26,15 @@ func TestSandboxRestore(t *testing.T) {
 	container := make(map[string]*Container)
 	container["test-exp"] = &Container{}
 
+	network, err := NewNetwork()
+	assert.NoError(err)
+
 	sandbox := Sandbox{
 		id:         "test-exp",
 		containers: container,
 		devManager: manager.NewDeviceManager(manager.VirtioSCSI, false, "", nil),
 		hypervisor: &mockHypervisor{},
+		network:    network,
 		ctx:        context.Background(),
 		config:     &sconfig,
 		state:      types.SandboxState{BlockIndexMap: make(map[int]struct{})},
diff --git a/src/runtime/virtcontainers/sandbox.go b/src/runtime/virtcontainers/sandbox.go
index 4f4677d946..3d9e711a61 100644
--- a/src/runtime/virtcontainers/sandbox.go
+++ b/src/runtime/virtcontainers/sandbox.go
@@ -211,8 +211,6 @@ type Sandbox struct {
 
 	state types.SandboxState
 
-	networkNS NetworkNamespace
-
 	sync.Mutex
 
 	swapSizeBytes int64
@@ -271,7 +269,7 @@ func (s *Sandbox) GetAnnotations() map[string]string {
 
 // GetNetNs returns the network namespace of the current sandbox.
 func (s *Sandbox) GetNetNs() string {
-	return s.networkNS.NetNsPath
+	return s.network.NetNSPath
 }
 
 // GetHypervisorPid returns the hypervisor's pid.
@@ -539,7 +537,6 @@ func newSandbox(ctx context.Context, sandboxConfig SandboxConfig, factory Factor
 		shmSize:         sandboxConfig.ShmSize,
 		sharePidNs:      sandboxConfig.SharePidNs,
 		network:         network,
-		networkNS:       NetworkNamespace{NetNsPath: sandboxConfig.NetworkConfig.NetNSPath},
 		ctx:             ctx,
 		swapDeviceNum:   0,
 		swapSizeBytes:   0,
@@ -814,23 +811,16 @@ func (s *Sandbox) createNetwork(ctx context.Context) error {
 	}
 
 	s.network = network
-	s.networkNS = NetworkNamespace{
-		NetNsPath:    s.config.NetworkConfig.NetNSPath,
-		NetNsCreated: s.config.NetworkConfig.NetNsCreated,
-	}
 
-	katatrace.AddTags(span, "networkNS", s.networkNS, "NetworkConfig", s.config.NetworkConfig)
+	katatrace.AddTags(span, "network", s.network, "NetworkConfig", s.config.NetworkConfig)
 
 	// In case there is a factory, network interfaces are hotplugged
 	// after vm is started.
 	if s.factory == nil {
 		// Add the network
-		endpoints, err := s.network.Add(ctx, s, false)
-		if err != nil {
+		if err := s.network.Add(ctx, s, false); err != nil {
 			return err
 		}
-
-		s.networkNS.Endpoints = endpoints
 	}
 	return nil
 }
@@ -913,7 +903,7 @@ func (s *Sandbox) AddInterface(ctx context.Context, inf *pbTypes.Interface) (*pb
 
 // RemoveInterface removes a nic of the sandbox.
 func (s *Sandbox) RemoveInterface(ctx context.Context, inf *pbTypes.Interface) (*pbTypes.Interface, error) {
-	for i, endpoint := range s.networkNS.Endpoints {
+	for i, endpoint := range s.network.Endpoints {
 		if endpoint.HardwareAddr() == inf.HwAddr {
 			s.Logger().WithField("endpoint-type", endpoint.Type()).Info("Hot detaching endpoint")
 			if err := s.network.detachEndpoint(ctx, s, i, true); err != nil {
@@ -1195,12 +1185,9 @@ func (s *Sandbox) startVM(ctx context.Context) (err error) {
 	// In case of vm factory, network interfaces are hotplugged
 	// after vm is started.
 	if s.factory != nil {
-		endpoints, err := s.network.Add(ctx, s, true)
-		if err != nil {
+		if err := s.network.Add(ctx, s, true); err != nil {
 			return err
 		}
-
-		s.networkNS.Endpoints = endpoints
 	}
 
 	s.Logger().Info("VM started")
diff --git a/src/runtime/virtcontainers/sandbox_test.go b/src/runtime/virtcontainers/sandbox_test.go
index 2dda62a418..c741caf7bc 100644
--- a/src/runtime/virtcontainers/sandbox_test.go
+++ b/src/runtime/virtcontainers/sandbox_test.go
@@ -1299,17 +1299,13 @@ func TestPreAddDevice(t *testing.T) {
 func TestGetNetNs(t *testing.T) {
 	s := Sandbox{}
 
-	expected := ""
+	expected := "/foo/bar/ns/net"
+	network, err := NewNetwork(&NetworkConfig{NetNSPath: expected})
+	assert.Nil(t, err)
+
+	s.network = network
 	netNs := s.GetNetNs()
 	assert.Equal(t, netNs, expected)
-
-	expected = "/foo/bar/ns/net"
-	s.networkNS = NetworkNamespace{
-		NetNsPath: expected,
-	}
-
-	netNs = s.GetNetNs()
-	assert.Equal(t, netNs, expected)
 }
 
 func TestSandboxStopStopped(t *testing.T) {