diff --git a/manager/api/grpc/client.go b/manager/api/grpc/client.go
index d2b1faf3..4dffe2c8 100644
--- a/manager/api/grpc/client.go
+++ b/manager/api/grpc/client.go
@@ -3,15 +3,20 @@
 package grpc
 
 import (
+	"bytes"
 	"context"
-	"errors"
 
+	"github.com/absmach/magistrala/pkg/errors"
 	"github.com/ultravioletrs/cocos/manager"
 	pkgmanager "github.com/ultravioletrs/cocos/pkg/manager"
 	"golang.org/x/sync/errgroup"
+	"google.golang.org/protobuf/proto"
 )
 
-var errTerminationFromServer = errors.New("server requested client termination")
+var (
+	errTerminationFromServer = errors.New("server requested client termination")
+	errCorruptedManifest     = errors.New("received manifest may be corrupted")
+)
 
 type ManagerClient struct {
 	stream    pkgmanager.ManagerService_ProcessClient
@@ -32,24 +37,41 @@ func (client ManagerClient) Process(ctx context.Context, cancel context.CancelFu
 	eg, ctx := errgroup.WithContext(ctx)
 
 	eg.Go(func() error {
+		var runReqBuffer bytes.Buffer
 		for {
 			req, err := client.stream.Recv()
 			if err != nil {
 				return err
 			}
+
 			switch mes := req.Message.(type) {
-			case *pkgmanager.ServerStreamMessage_RunReq:
-				port, err := client.svc.Run(ctx, mes.RunReq)
-				if err != nil {
-					return err
+			case *pkgmanager.ServerStreamMessage_RunReqChunks:
+				if len(mes.RunReqChunks.Data) == 0 {
+					var runReq pkgmanager.ComputationRunReq
+					if err = proto.Unmarshal(runReqBuffer.Bytes(), &runReq); err != nil {
+						return errors.Wrap(err, errCorruptedManifest)
+					}
+					port, err := client.svc.Run(ctx, &runReq)
+					if err != nil {
+						return err
+					}
+					runRes := &pkgmanager.ClientStreamMessage_RunRes{
+						RunRes: &pkgmanager.RunResponse{
+							AgentPort:     port,
+							ComputationId: runReq.Id,
+						},
+					}
+					if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: runRes}); err != nil {
+						return err
+					}
 				}
-				runRes := &pkgmanager.ClientStreamMessage_RunRes{RunRes: &pkgmanager.RunResponse{AgentPort: port, ComputationId: mes.RunReq.Id}}
-				if err := client.stream.Send(&pkgmanager.ClientStreamMessage{Message: runRes}); err != nil {
+				if _, err := runReqBuffer.Write(mes.RunReqChunks.Data); err != nil {
 					return err
 				}
+
 			case *pkgmanager.ServerStreamMessage_TerminateReq:
 				cancel()
-				return errors.Join(errTerminationFromServer, errors.New(mes.TerminateReq.Message))
+				return errors.Wrap(errTerminationFromServer, errors.New(mes.TerminateReq.Message))
 			case *pkgmanager.ServerStreamMessage_StopComputation:
 				if err := client.svc.Stop(ctx, mes.StopComputation.ComputationId); err != nil {
 					return err
diff --git a/manager/api/grpc/server.go b/manager/api/grpc/server.go
index b922a719..a5a7abb9 100644
--- a/manager/api/grpc/server.go
+++ b/manager/api/grpc/server.go
@@ -3,13 +3,23 @@
 package grpc
 
 import (
+	"bytes"
+	"errors"
+	"io"
+
 	"github.com/ultravioletrs/cocos/pkg/manager"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/peer"
+	"google.golang.org/protobuf/proto"
+)
+
+var (
+	_                manager.ManagerServiceServer = (*grpcServer)(nil)
+	ErrUnexpectedMsg                              = errors.New("unknown message type")
 )
 
-var _ manager.ManagerServiceServer = (*grpcServer)(nil)
+const bufferSize = 1024 * 1024 // 1 MB
 
 type grpcServer struct {
 	manager.UnimplementedManagerServiceServer
@@ -54,8 +64,37 @@ func (s *grpcServer) Process(stream manager.ManagerService_ProcessServer) error
 			case <-ctx.Done():
 				return nil
 			case req := <-runReqChan:
-				if err := stream.Send(req); err != nil {
-					return err
+				switch msg := req.Message.(type) {
+				case *manager.ServerStreamMessage_RunReq:
+					data, err := proto.Marshal(msg.RunReq)
+					if err != nil {
+						return err
+					}
+					dataBuffer := bytes.NewBuffer(data)
+					buf := make([]byte, bufferSize)
+					for {
+						n, err := dataBuffer.Read(buf)
+						chunk := &manager.ServerStreamMessage{
+							Message: &manager.ServerStreamMessage_RunReqChunks{
+								RunReqChunks: &manager.RunReqChunks{
+									Data: buf[:n],
+								},
+							},
+						}
+
+						if err := stream.Send(chunk); err != nil {
+							return err
+						}
+
+						if err == io.EOF {
+							break
+						}
+					}
+
+				default:
+					if err := stream.Send(req); err != nil {
+						return err
+					}
 				}
 			}
 		}
diff --git a/manager/manager.proto b/manager/manager.proto
index e4c36755..075a3383 100644
--- a/manager/manager.proto
+++ b/manager/manager.proto
@@ -58,13 +58,18 @@ message ClientStreamMessage {
 
 message ServerStreamMessage {
   oneof message {
-    ComputationRunReq runReq = 1;
-    Terminate terminateReq = 2;
-    StopComputation stopComputation = 3;
-    BackendInfoReq backendInfoReq = 4;
+    RunReqChunks runReqChunks = 1;
+    ComputationRunReq runReq = 2;
+    Terminate terminateReq = 3;
+    StopComputation stopComputation = 4;
+    BackendInfoReq backendInfoReq = 5;
   }
 }
 
+message RunReqChunks {
+  bytes data = 1;
+}
+
 message ComputationRunReq {
   string id = 1;
   string name = 2;
diff --git a/manager/manager_test.go b/manager/manager_test.go
index 1babee22..33265782 100644
--- a/manager/manager_test.go
+++ b/manager/manager_test.go
@@ -1,232 +1,68 @@
 // Copyright (c) Ultraviolet
 // SPDX-License-Identifier: Apache-2.0
-package manager
+package manager_test
 
 import (
+	"bytes"
 	"context"
-	"encoding/json"
-	"log/slog"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/ultravioletrs/cocos/manager/qemu"
-	"github.com/ultravioletrs/cocos/manager/vm"
-	"github.com/ultravioletrs/cocos/manager/vm/mocks"
 	"github.com/ultravioletrs/cocos/pkg/manager"
+	"google.golang.org/grpc"
+	"google.golang.org/protobuf/proto"
 )
 
-func TestNew(t *testing.T) {
-	cfg := qemu.Config{}
-	logger := slog.Default()
-	eventsChan := make(chan *manager.ClientStreamMessage)
-	vmf := new(mocks.Provider)
-
-	service := New(cfg, "", logger, eventsChan, vmf.Execute)
-
-	assert.NotNil(t, service)
-	assert.IsType(t, &managerService{}, service)
-}
-
-func TestRun(t *testing.T) {
-	vmf := new(mocks.Provider)
-	vmMock := new(mocks.VM)
-	vmf.On("Execute", mock.Anything, mock.Anything, mock.Anything).Return(vmMock)
-	tests := []struct {
-		name          string
-		req           *manager.ComputationRunReq
-		vmStartError  error
-		expectedError error
-	}{
-		{
-			name: "Successful run",
-			req: &manager.ComputationRunReq{
-				Id:   "test-computation",
-				Name: "Test Computation",
-				Algorithm: &manager.Algorithm{
-					Hash: make([]byte, hashLength),
-				},
-				AgentConfig: &manager.AgentConfig{},
-			},
-			vmStartError:  nil,
-			expectedError: nil,
-		},
-		{
-			name: "VM start failure",
-			req: &manager.ComputationRunReq{
-				Id:   "test-computation",
-				Name: "Test Computation",
-				Algorithm: &manager.Algorithm{
-					Hash: make([]byte, hashLength),
-				},
-				AgentConfig: &manager.AgentConfig{},
-			},
-			vmStartError:  assert.AnError,
-			expectedError: assert.AnError,
-		},
+func TestProcess(t *testing.T) {
+	ctx := context.Background()
+	conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(bufDialer), grpc.WithInsecure())
+	if err != nil {
+		t.Fatalf("Failed to dial bufnet: %v", err)
 	}
+	defer conn.Close()
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if tt.vmStartError == nil {
-				vmMock.On("Start").Return(nil).Once()
-			} else {
-				vmMock.On("Start").Return(tt.vmStartError).Once()
-			}
-
-			vmMock.On("SendAgentConfig", mock.Anything).Return(nil)
-
-			qemuCfg := qemu.Config{
-				VSockConfig: qemu.VSockConfig{
-					GuestCID: 3,
-					Vnc:      5900,
-				},
-			}
-			logger := slog.Default()
-			eventsChan := make(chan *manager.ClientStreamMessage, 10)
-
-			ms := &managerService{
-				qemuCfg:    qemuCfg,
-				logger:     logger,
-				agents:     make(map[int]string),
-				vms:        make(map[string]vm.VM),
-				eventsChan: eventsChan,
-				vmFactory:  vmf.Execute,
-			}
-
-			ctx := context.Background()
-
-			port, err := ms.Run(ctx, tt.req)
-
-			if tt.expectedError != nil {
-				assert.Error(t, err)
-				assert.ErrorIs(t, err, tt.expectedError)
-				assert.Empty(t, port)
-			} else {
-				assert.NoError(t, err)
-				assert.NotEmpty(t, port)
-				assert.Len(t, ms.vms, 1)
-				assert.Len(t, ms.agents, 1)
-			}
-
-			vmf.AssertExpectations(t)
-
-			// Clear the events channel
-			for len(eventsChan) > 0 {
-				<-eventsChan
-			}
-		})
+	client := manager.NewManagerServiceClient(conn)
+	stream, err := client.Process(ctx)
+	if err != nil {
+		t.Fatalf("Process failed: %v", err)
 	}
-}
 
-func TestStop(t *testing.T) {
-	tests := []struct {
-		name           string
-		computationID  string
-		vmStopError    error
-		expectedError  error
-		initialVMCount int
-	}{
-		{
-			name:           "Successful stop",
-			computationID:  "existing-computation",
-			vmStopError:    nil,
-			expectedError:  nil,
-			initialVMCount: 1,
-		},
-		{
-			name:           "Non-existent computation",
-			computationID:  "non-existent-computation",
-			vmStopError:    nil,
-			expectedError:  ErrNotFound,
-			initialVMCount: 0,
-		},
-		{
-			name:           "VM stop error",
-			computationID:  "error-computation",
-			vmStopError:    assert.AnError,
-			expectedError:  assert.AnError,
-			initialVMCount: 1,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			ms := &managerService{
-				vms: make(map[string]vm.VM),
-			}
-			vmMock := new(mocks.VM)
-
-			if tt.vmStopError == nil {
-				vmMock.On("Stop").Return(nil).Once()
-			} else {
-				vmMock.On("Stop").Return(assert.AnError).Once()
-			}
-
-			if tt.initialVMCount > 0 {
-				ms.vms[tt.computationID] = vmMock
+	var data bytes.Buffer
+	for {
+		msg, err := stream.Recv()
+		if err != nil {
+			t.Fatalf("Failed to receive ServerStreamMessage: %v", err)
+		}
+
+		switch m := msg.Message.(type) {
+		case *manager.ServerStreamMessage_TerminateReq:
+			if m.TerminateReq.Message != "test terminate" {
+				t.Fatalf("Unexpected terminate message: %v", m.TerminateReq.Message)
 			}
-
-			err := ms.Stop(context.Background(), tt.computationID)
-
-			if tt.expectedError != nil {
-				assert.Error(t, err)
-				assert.ErrorIs(t, err, tt.expectedError)
-			} else {
-				assert.NoError(t, err)
-				assert.Len(t, ms.vms, 0)
-			}
-		})
-	}
-}
-
-func TestGetFreePort(t *testing.T) {
-	port, err := getFreePort()
-
-	assert.NoError(t, err)
-	assert.Greater(t, port, 0)
-}
-
-func TestPublishEvent(t *testing.T) {
-	tests := []struct {
-		name          string
-		event         string
-		computationID string
-		status        string
-		details       json.RawMessage
-	}{
-		{
-			name:          "Standard event",
-			event:         "test-event",
-			computationID: "test-computation",
-			status:        "test-status",
-			details:       nil,
-		},
-		{
-			name:          "Event with details",
-			event:         "detailed-event",
-			computationID: "detailed-computation",
-			status:        "detailed-status",
-			details:       json.RawMessage(`{"key": "value"}`),
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			eventsChan := make(chan *manager.ClientStreamMessage, 1)
-			ms := &managerService{
-				eventsChan: eventsChan,
+		case *manager.ServerStreamMessage_RunReqChunks:
+			if len(m.RunReqChunks.Data) == 0 {
+				var runReq manager.ComputationRunReq
+				if err = proto.Unmarshal(data.Bytes(), &runReq); err != nil {
+					t.Fatalf("Failed to create run request: %v", err)
+				}
+
+				runRes := &manager.ClientStreamMessage_AgentLog{
+					AgentLog: &manager.AgentLog{
+						Message:       "test log",
+						ComputationId: "comp1",
+						Level:         "DEBUG",
+					},
+				}
+				if runReq.Id != "1" || runReq.Name != "sample computation" || runReq.Description != "sample description" {
+					t.Fatalf("Unexpected run request message: %v", &runReq)
+				}
+				if err := stream.Send(&manager.ClientStreamMessage{Message: runRes}); err != nil {
+					t.Fatalf("Failed to send ClientStreamMessage: %v", err)
+				}
+				return
 			}
-
-			ms.publishEvent(tt.event, tt.computationID, tt.status, tt.details)
-
-			assert.Len(t, eventsChan, 1)
-			event := <-eventsChan
-			assert.Equal(t, tt.event, event.GetAgentEvent().EventType)
-			assert.Equal(t, tt.computationID, event.GetAgentEvent().ComputationId)
-			assert.Equal(t, tt.status, event.GetAgentEvent().Status)
-			assert.Equal(t, "manager", event.GetAgentEvent().Originator)
-			assert.Equal(t, tt.details, json.RawMessage(event.GetAgentEvent().Details))
-		})
+			data.Write(m.RunReqChunks.Data)
+		default:
+			t.Fatalf("Unexpected message type: %T", m)
+		}
 	}
 }
diff --git a/manager/service_test.go b/manager/service_test.go
new file mode 100644
index 00000000..1babee22
--- /dev/null
+++ b/manager/service_test.go
@@ -0,0 +1,232 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package manager
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/ultravioletrs/cocos/manager/qemu"
+	"github.com/ultravioletrs/cocos/manager/vm"
+	"github.com/ultravioletrs/cocos/manager/vm/mocks"
+	"github.com/ultravioletrs/cocos/pkg/manager"
+)
+
+func TestNew(t *testing.T) {
+	cfg := qemu.Config{}
+	logger := slog.Default()
+	eventsChan := make(chan *manager.ClientStreamMessage)
+	vmf := new(mocks.Provider)
+
+	service := New(cfg, "", logger, eventsChan, vmf.Execute)
+
+	assert.NotNil(t, service)
+	assert.IsType(t, &managerService{}, service)
+}
+
+func TestRun(t *testing.T) {
+	vmf := new(mocks.Provider)
+	vmMock := new(mocks.VM)
+	vmf.On("Execute", mock.Anything, mock.Anything, mock.Anything).Return(vmMock)
+	tests := []struct {
+		name          string
+		req           *manager.ComputationRunReq
+		vmStartError  error
+		expectedError error
+	}{
+		{
+			name: "Successful run",
+			req: &manager.ComputationRunReq{
+				Id:   "test-computation",
+				Name: "Test Computation",
+				Algorithm: &manager.Algorithm{
+					Hash: make([]byte, hashLength),
+				},
+				AgentConfig: &manager.AgentConfig{},
+			},
+			vmStartError:  nil,
+			expectedError: nil,
+		},
+		{
+			name: "VM start failure",
+			req: &manager.ComputationRunReq{
+				Id:   "test-computation",
+				Name: "Test Computation",
+				Algorithm: &manager.Algorithm{
+					Hash: make([]byte, hashLength),
+				},
+				AgentConfig: &manager.AgentConfig{},
+			},
+			vmStartError:  assert.AnError,
+			expectedError: assert.AnError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.vmStartError == nil {
+				vmMock.On("Start").Return(nil).Once()
+			} else {
+				vmMock.On("Start").Return(tt.vmStartError).Once()
+			}
+
+			vmMock.On("SendAgentConfig", mock.Anything).Return(nil)
+
+			qemuCfg := qemu.Config{
+				VSockConfig: qemu.VSockConfig{
+					GuestCID: 3,
+					Vnc:      5900,
+				},
+			}
+			logger := slog.Default()
+			eventsChan := make(chan *manager.ClientStreamMessage, 10)
+
+			ms := &managerService{
+				qemuCfg:    qemuCfg,
+				logger:     logger,
+				agents:     make(map[int]string),
+				vms:        make(map[string]vm.VM),
+				eventsChan: eventsChan,
+				vmFactory:  vmf.Execute,
+			}
+
+			ctx := context.Background()
+
+			port, err := ms.Run(ctx, tt.req)
+
+			if tt.expectedError != nil {
+				assert.Error(t, err)
+				assert.ErrorIs(t, err, tt.expectedError)
+				assert.Empty(t, port)
+			} else {
+				assert.NoError(t, err)
+				assert.NotEmpty(t, port)
+				assert.Len(t, ms.vms, 1)
+				assert.Len(t, ms.agents, 1)
+			}
+
+			vmf.AssertExpectations(t)
+
+			// Clear the events channel
+			for len(eventsChan) > 0 {
+				<-eventsChan
+			}
+		})
+	}
+}
+
+func TestStop(t *testing.T) {
+	tests := []struct {
+		name           string
+		computationID  string
+		vmStopError    error
+		expectedError  error
+		initialVMCount int
+	}{
+		{
+			name:           "Successful stop",
+			computationID:  "existing-computation",
+			vmStopError:    nil,
+			expectedError:  nil,
+			initialVMCount: 1,
+		},
+		{
+			name:           "Non-existent computation",
+			computationID:  "non-existent-computation",
+			vmStopError:    nil,
+			expectedError:  ErrNotFound,
+			initialVMCount: 0,
+		},
+		{
+			name:           "VM stop error",
+			computationID:  "error-computation",
+			vmStopError:    assert.AnError,
+			expectedError:  assert.AnError,
+			initialVMCount: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ms := &managerService{
+				vms: make(map[string]vm.VM),
+			}
+			vmMock := new(mocks.VM)
+
+			if tt.vmStopError == nil {
+				vmMock.On("Stop").Return(nil).Once()
+			} else {
+				vmMock.On("Stop").Return(assert.AnError).Once()
+			}
+
+			if tt.initialVMCount > 0 {
+				ms.vms[tt.computationID] = vmMock
+			}
+
+			err := ms.Stop(context.Background(), tt.computationID)
+
+			if tt.expectedError != nil {
+				assert.Error(t, err)
+				assert.ErrorIs(t, err, tt.expectedError)
+			} else {
+				assert.NoError(t, err)
+				assert.Len(t, ms.vms, 0)
+			}
+		})
+	}
+}
+
+func TestGetFreePort(t *testing.T) {
+	port, err := getFreePort()
+
+	assert.NoError(t, err)
+	assert.Greater(t, port, 0)
+}
+
+func TestPublishEvent(t *testing.T) {
+	tests := []struct {
+		name          string
+		event         string
+		computationID string
+		status        string
+		details       json.RawMessage
+	}{
+		{
+			name:          "Standard event",
+			event:         "test-event",
+			computationID: "test-computation",
+			status:        "test-status",
+			details:       nil,
+		},
+		{
+			name:          "Event with details",
+			event:         "detailed-event",
+			computationID: "detailed-computation",
+			status:        "detailed-status",
+			details:       json.RawMessage(`{"key": "value"}`),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			eventsChan := make(chan *manager.ClientStreamMessage, 1)
+			ms := &managerService{
+				eventsChan: eventsChan,
+			}
+
+			ms.publishEvent(tt.event, tt.computationID, tt.status, tt.details)
+
+			assert.Len(t, eventsChan, 1)
+			event := <-eventsChan
+			assert.Equal(t, tt.event, event.GetAgentEvent().EventType)
+			assert.Equal(t, tt.computationID, event.GetAgentEvent().ComputationId)
+			assert.Equal(t, tt.status, event.GetAgentEvent().Status)
+			assert.Equal(t, "manager", event.GetAgentEvent().Originator)
+			assert.Equal(t, tt.details, json.RawMessage(event.GetAgentEvent().Details))
+		})
+	}
+}
diff --git a/manager/setup_test.go b/manager/setup_test.go
new file mode 100644
index 00000000..442bf424
--- /dev/null
+++ b/manager/setup_test.go
@@ -0,0 +1,126 @@
+// Copyright (c) Ultraviolet
+// SPDX-License-Identifier: Apache-2.0
+package manager_test
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"log/slog"
+	"net"
+	"os"
+	"testing"
+	"time"
+
+	mglog "github.com/absmach/magistrala/logger"
+	managergrpc "github.com/ultravioletrs/cocos/manager/api/grpc"
+	"github.com/ultravioletrs/cocos/pkg/manager"
+	"golang.org/x/crypto/sha3"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/test/bufconn"
+)
+
+const (
+	bufSize    = 1024 * 1024
+	keyBitSize = 4096
+)
+
+var (
+	lis         *bufconn.Listener
+	algoPath    = "../test/manual/algo/lin_reg.py"
+	dataPath    = "../test/manual/data/iris.csv"
+	attestedTLS = false
+)
+
+type svc struct {
+	logger *slog.Logger
+	t      *testing.T
+}
+
+func TestMain(m *testing.M) {
+	logger := mglog.NewMock()
+
+	lis = bufconn.Listen(bufSize)
+	s := grpc.NewServer()
+
+	manager.RegisterManagerServiceServer(s, managergrpc.NewServer(make(chan *manager.ClientStreamMessage, 1), &svc{logger: logger}))
+	go func() {
+		if err := s.Serve(lis); err != nil {
+			panic(err)
+		}
+	}()
+
+	code := m.Run()
+
+	s.Stop()
+	lis.Close()
+	os.Exit(code)
+}
+
+func bufDialer(context.Context, string) (net.Conn, error) {
+	return lis.Dial()
+}
+
+func (s *svc) Run(ipAddress string, runReqChan chan *manager.ServerStreamMessage, authInfo credentials.AuthInfo) {
+	privKey, err := rsa.GenerateKey(rand.Reader, keyBitSize)
+	if err != nil {
+		s.t.Fatalf("Error generating public key: %v", err)
+	}
+
+	pubKey, err := x509.MarshalPKIXPublicKey(&privKey.PublicKey)
+	if err != nil {
+		s.t.Fatalf("Error marshalling public key: %v", err)
+	}
+
+	pubPemBytes := pem.EncodeToMemory(&pem.Block{
+		Type:  "PUBLIC KEY",
+		Bytes: pubKey,
+	})
+
+	go func() {
+		time.Sleep(time.Millisecond * 100)
+		runReqChan <- &manager.ServerStreamMessage{
+			Message: &manager.ServerStreamMessage_TerminateReq{
+				TerminateReq: &manager.Terminate{Message: "test terminate"},
+			},
+		}
+	}()
+
+	go func() {
+		time.Sleep(time.Millisecond * 100)
+		algo, err := os.ReadFile(algoPath)
+		if err != nil {
+			s.t.Fatalf("failed to read algorithm file: %s", err)
+			return
+		}
+		data, err := os.ReadFile(dataPath)
+		if err != nil {
+			s.t.Fatalf("failed to read data file: %s", err)
+			return
+		}
+
+		pubPem, _ := pem.Decode(pubPemBytes)
+		algoHash := sha3.Sum256(algo)
+		dataHash := sha3.Sum256(data)
+		runReqChan <- &manager.ServerStreamMessage{
+			Message: &manager.ServerStreamMessage_RunReq{
+				RunReq: &manager.ComputationRunReq{
+					Id:              "1",
+					Name:            "sample computation",
+					Description:     "sample description",
+					Datasets:        []*manager.Dataset{{Hash: dataHash[:], UserKey: pubPem.Bytes}},
+					Algorithm:       &manager.Algorithm{Hash: algoHash[:], UserKey: pubPem.Bytes},
+					ResultConsumers: []*manager.ResultConsumer{{UserKey: pubPem.Bytes}},
+					AgentConfig: &manager.AgentConfig{
+						Port:        "7002",
+						LogLevel:    "debug",
+						AttestedTls: attestedTLS,
+					},
+				},
+			},
+		}
+	}()
+}
diff --git a/pkg/manager/manager.pb.go b/pkg/manager/manager.pb.go
index 3048e53a..1c8a3478 100644
--- a/pkg/manager/manager.pb.go
+++ b/pkg/manager/manager.pb.go
@@ -502,6 +502,7 @@ type ServerStreamMessage struct {
 
 	// Types that are assignable to Message:
 	//
+	//	*ServerStreamMessage_RunReqChunks
 	//	*ServerStreamMessage_RunReq
 	//	*ServerStreamMessage_TerminateReq
 	//	*ServerStreamMessage_StopComputation
@@ -548,6 +549,13 @@ func (m *ServerStreamMessage) GetMessage() isServerStreamMessage_Message {
 	return nil
 }
 
+func (x *ServerStreamMessage) GetRunReqChunks() *RunReqChunks {
+	if x, ok := x.GetMessage().(*ServerStreamMessage_RunReqChunks); ok {
+		return x.RunReqChunks
+	}
+	return nil
+}
+
 func (x *ServerStreamMessage) GetRunReq() *ComputationRunReq {
 	if x, ok := x.GetMessage().(*ServerStreamMessage_RunReq); ok {
 		return x.RunReq
@@ -580,22 +588,28 @@ type isServerStreamMessage_Message interface {
 	isServerStreamMessage_Message()
 }
 
+type ServerStreamMessage_RunReqChunks struct {
+	RunReqChunks *RunReqChunks `protobuf:"bytes,1,opt,name=runReqChunks,proto3,oneof"`
+}
+
 type ServerStreamMessage_RunReq struct {
-	RunReq *ComputationRunReq `protobuf:"bytes,1,opt,name=runReq,proto3,oneof"`
+	RunReq *ComputationRunReq `protobuf:"bytes,2,opt,name=runReq,proto3,oneof"`
 }
 
 type ServerStreamMessage_TerminateReq struct {
-	TerminateReq *Terminate `protobuf:"bytes,2,opt,name=terminateReq,proto3,oneof"`
+	TerminateReq *Terminate `protobuf:"bytes,3,opt,name=terminateReq,proto3,oneof"`
 }
 
 type ServerStreamMessage_StopComputation struct {
-	StopComputation *StopComputation `protobuf:"bytes,3,opt,name=stopComputation,proto3,oneof"`
+	StopComputation *StopComputation `protobuf:"bytes,4,opt,name=stopComputation,proto3,oneof"`
 }
 
 type ServerStreamMessage_BackendInfoReq struct {
-	BackendInfoReq *BackendInfoReq `protobuf:"bytes,4,opt,name=backendInfoReq,proto3,oneof"`
+	BackendInfoReq *BackendInfoReq `protobuf:"bytes,5,opt,name=backendInfoReq,proto3,oneof"`
 }
 
+func (*ServerStreamMessage_RunReqChunks) isServerStreamMessage_Message() {}
+
 func (*ServerStreamMessage_RunReq) isServerStreamMessage_Message() {}
 
 func (*ServerStreamMessage_TerminateReq) isServerStreamMessage_Message() {}
@@ -604,6 +618,53 @@ func (*ServerStreamMessage_StopComputation) isServerStreamMessage_Message() {}
 
 func (*ServerStreamMessage_BackendInfoReq) isServerStreamMessage_Message() {}
 
+type RunReqChunks struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *RunReqChunks) Reset() {
+	*x = RunReqChunks{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_manager_manager_proto_msgTypes[8]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RunReqChunks) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RunReqChunks) ProtoMessage() {}
+
+func (x *RunReqChunks) ProtoReflect() protoreflect.Message {
+	mi := &file_manager_manager_proto_msgTypes[8]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RunReqChunks.ProtoReflect.Descriptor instead.
+func (*RunReqChunks) Descriptor() ([]byte, []int) {
+	return file_manager_manager_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *RunReqChunks) GetData() []byte {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
 type ComputationRunReq struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -621,7 +682,7 @@ type ComputationRunReq struct {
 func (x *ComputationRunReq) Reset() {
 	*x = ComputationRunReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[8]
+		mi := &file_manager_manager_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -634,7 +695,7 @@ func (x *ComputationRunReq) String() string {
 func (*ComputationRunReq) ProtoMessage() {}
 
 func (x *ComputationRunReq) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[8]
+	mi := &file_manager_manager_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -647,7 +708,7 @@ func (x *ComputationRunReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ComputationRunReq.ProtoReflect.Descriptor instead.
 func (*ComputationRunReq) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{8}
+	return file_manager_manager_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *ComputationRunReq) GetId() string {
@@ -710,7 +771,7 @@ type BackendInfoReq struct {
 func (x *BackendInfoReq) Reset() {
 	*x = BackendInfoReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[9]
+		mi := &file_manager_manager_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -723,7 +784,7 @@ func (x *BackendInfoReq) String() string {
 func (*BackendInfoReq) ProtoMessage() {}
 
 func (x *BackendInfoReq) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[9]
+	mi := &file_manager_manager_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -736,7 +797,7 @@ func (x *BackendInfoReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use BackendInfoReq.ProtoReflect.Descriptor instead.
 func (*BackendInfoReq) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{9}
+	return file_manager_manager_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *BackendInfoReq) GetId() string {
@@ -757,7 +818,7 @@ type ResultConsumer struct {
 func (x *ResultConsumer) Reset() {
 	*x = ResultConsumer{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[10]
+		mi := &file_manager_manager_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -770,7 +831,7 @@ func (x *ResultConsumer) String() string {
 func (*ResultConsumer) ProtoMessage() {}
 
 func (x *ResultConsumer) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[10]
+	mi := &file_manager_manager_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -783,7 +844,7 @@ func (x *ResultConsumer) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ResultConsumer.ProtoReflect.Descriptor instead.
 func (*ResultConsumer) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{10}
+	return file_manager_manager_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *ResultConsumer) GetUserKey() []byte {
@@ -805,7 +866,7 @@ type Dataset struct {
 func (x *Dataset) Reset() {
 	*x = Dataset{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[11]
+		mi := &file_manager_manager_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -818,7 +879,7 @@ func (x *Dataset) String() string {
 func (*Dataset) ProtoMessage() {}
 
 func (x *Dataset) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[11]
+	mi := &file_manager_manager_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -831,7 +892,7 @@ func (x *Dataset) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Dataset.ProtoReflect.Descriptor instead.
 func (*Dataset) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{11}
+	return file_manager_manager_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *Dataset) GetHash() []byte {
@@ -860,7 +921,7 @@ type Algorithm struct {
 func (x *Algorithm) Reset() {
 	*x = Algorithm{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[12]
+		mi := &file_manager_manager_proto_msgTypes[13]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -873,7 +934,7 @@ func (x *Algorithm) String() string {
 func (*Algorithm) ProtoMessage() {}
 
 func (x *Algorithm) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[12]
+	mi := &file_manager_manager_proto_msgTypes[13]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -886,7 +947,7 @@ func (x *Algorithm) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Algorithm.ProtoReflect.Descriptor instead.
 func (*Algorithm) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{12}
+	return file_manager_manager_proto_rawDescGZIP(), []int{13}
 }
 
 func (x *Algorithm) GetHash() []byte {
@@ -921,7 +982,7 @@ type AgentConfig struct {
 func (x *AgentConfig) Reset() {
 	*x = AgentConfig{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_manager_manager_proto_msgTypes[13]
+		mi := &file_manager_manager_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -934,7 +995,7 @@ func (x *AgentConfig) String() string {
 func (*AgentConfig) ProtoMessage() {}
 
 func (x *AgentConfig) ProtoReflect() protoreflect.Message {
-	mi := &file_manager_manager_proto_msgTypes[13]
+	mi := &file_manager_manager_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -947,7 +1008,7 @@ func (x *AgentConfig) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use AgentConfig.ProtoReflect.Descriptor instead.
 func (*AgentConfig) Descriptor() ([]byte, []int) {
-	return file_manager_manager_proto_rawDescGZIP(), []int{13}
+	return file_manager_manager_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *AgentConfig) GetPort() string {
@@ -1067,79 +1128,85 @@ var file_manager_manager_proto_rawDesc = []byte{
 	0x0b, 0x32, 0x14, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x42, 0x61, 0x63, 0x6b,
 	0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x48, 0x00, 0x52, 0x0b, 0x62, 0x61, 0x63, 0x6b, 0x65,
 	0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x22, 0x99, 0x02, 0x0a, 0x13, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65,
-	0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x72, 0x75, 0x6e,
-	0x52, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6d, 0x61, 0x6e, 0x61,
-	0x67, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x75, 0x6e, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x12,
-	0x38, 0x0a, 0x0c, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e,
-	0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x74, 0x65, 0x72,
-	0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x12, 0x44, 0x0a, 0x0f, 0x73, 0x74, 0x6f,
-	0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x53, 0x74, 0x6f,
-	0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0f,
-	0x73, 0x74, 0x6f, 0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x41, 0x0a, 0x0e, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65,
-	0x71, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
-	0x72, 0x2e, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
-	0x48, 0x00, 0x52, 0x0e, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52,
-	0x65, 0x71, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xb6, 0x02,
-	0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6e,
-	0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72,
-	0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65,
-	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x08, 0x64, 0x61, 0x74,
-	0x61, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6d, 0x61,
-	0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x52, 0x08, 0x64,
-	0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72,
-	0x69, 0x74, 0x68, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x61, 0x6e,
-	0x61, 0x67, 0x65, 0x72, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x52, 0x09,
-	0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65, 0x73,
-	0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x52, 0x65,
-	0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x52, 0x0f, 0x72, 0x65,
-	0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x12, 0x37, 0x0a,
-	0x0c, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x61, 0x67, 0x65, 0x6e, 0x74,
-	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x20, 0x0a, 0x0e, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e,
-	0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x2a, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75,
-	0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73,
-	0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65,
-	0x72, 0x4b, 0x65, 0x79, 0x22, 0x37, 0x0a, 0x07, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12,
-	0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68,
-	0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0x39, 0x0a,
-	0x09, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61,
-	0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x18,
-	0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0xf9, 0x01, 0x0a, 0x0b, 0x41, 0x67, 0x65,
-	0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04,
-	0x68, 0x6f, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74,
-	0x12, 0x1b, 0x0a, 0x09, 0x63, 0x65, 0x72, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x65, 0x72, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x19, 0x0a,
-	0x08, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x07, 0x6b, 0x65, 0x79, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24,
-	0x0a, 0x0e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x43, 0x61,
-	0x46, 0x69, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x65, 0x76, 0x65,
-	0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x65, 0x76, 0x65,
-	0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x6c,
-	0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65,
-	0x64, 0x54, 0x6c, 0x73, 0x32, 0x5d, 0x0a, 0x0e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x53,
-	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4b, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73,
-	0x73, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x43, 0x6c, 0x69, 0x65,
-	0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a,
-	0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
-	0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x28,
-	0x01, 0x30, 0x01, 0x42, 0x0b, 0x5a, 0x09, 0x2e, 0x2f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x65, 0x22, 0xd6, 0x02, 0x0a, 0x13, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x0c, 0x72, 0x75, 0x6e,
+	0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x15, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71,
+	0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71,
+	0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x12, 0x34, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72,
+	0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6e, 0x52,
+	0x65, 0x71, 0x48, 0x00, 0x52, 0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x12, 0x38, 0x0a, 0x0c,
+	0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x54, 0x65, 0x72,
+	0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e,
+	0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x12, 0x44, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x43, 0x6f,
+	0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x18, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x43, 0x6f,
+	0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0f, 0x73, 0x74, 0x6f,
+	0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0e,
+	0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x42,
+	0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52,
+	0x0e, 0x62, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x42,
+	0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x22, 0x0a, 0x0c, 0x52, 0x75,
+	0x6e, 0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61,
+	0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0xb6,
+	0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75,
+	0x6e, 0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63,
+	0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x0a, 0x08, 0x64, 0x61,
+	0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6d,
+	0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x52, 0x08,
+	0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x12, 0x30, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f,
+	0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, 0x61,
+	0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x52,
+	0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x42, 0x0a, 0x10, 0x72, 0x65,
+	0x73, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x18, 0x06,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x52,
+	0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x52, 0x0f, 0x72,
+	0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x12, 0x37,
+	0x0a, 0x0c, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x41,
+	0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x61, 0x67, 0x65, 0x6e,
+	0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x20, 0x0a, 0x0e, 0x42, 0x61, 0x63, 0x6b, 0x65,
+	0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x2a, 0x0a, 0x0e, 0x52, 0x65, 0x73,
+	0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x75,
+	0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73,
+	0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0x37, 0x0a, 0x07, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74,
+	0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
+	0x68, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0x39,
+	0x0a, 0x09, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x68,
+	0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12,
+	0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
+	0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0xf9, 0x01, 0x0a, 0x0b, 0x41, 0x67,
+	0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72,
+	0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a,
+	0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73,
+	0x74, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x65, 0x72, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x65, 0x72, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x19,
+	0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x07, 0x6b, 0x65, 0x79, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x12,
+	0x24, 0x0a, 0x0e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c,
+	0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x43,
+	0x61, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x65, 0x76,
+	0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x65, 0x76,
+	0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74,
+	0x6c, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74,
+	0x65, 0x64, 0x54, 0x6c, 0x73, 0x32, 0x5d, 0x0a, 0x0e, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4b, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x63, 0x65,
+	0x73, 0x73, 0x12, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x43, 0x6c, 0x69,
+	0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x1a, 0x1c, 0x2e, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65,
+	0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00,
+	0x28, 0x01, 0x30, 0x01, 0x42, 0x0b, 0x5a, 0x09, 0x2e, 0x2f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65,
+	0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1154,7 +1221,7 @@ func file_manager_manager_proto_rawDescGZIP() []byte {
 	return file_manager_manager_proto_rawDescData
 }
 
-var file_manager_manager_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
+var file_manager_manager_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
 var file_manager_manager_proto_goTypes = []any{
 	(*Terminate)(nil),             // 0: manager.Terminate
 	(*StopComputation)(nil),       // 1: manager.StopComputation
@@ -1164,36 +1231,38 @@ var file_manager_manager_proto_goTypes = []any{
 	(*AgentLog)(nil),              // 5: manager.AgentLog
 	(*ClientStreamMessage)(nil),   // 6: manager.ClientStreamMessage
 	(*ServerStreamMessage)(nil),   // 7: manager.ServerStreamMessage
-	(*ComputationRunReq)(nil),     // 8: manager.ComputationRunReq
-	(*BackendInfoReq)(nil),        // 9: manager.BackendInfoReq
-	(*ResultConsumer)(nil),        // 10: manager.ResultConsumer
-	(*Dataset)(nil),               // 11: manager.Dataset
-	(*Algorithm)(nil),             // 12: manager.Algorithm
-	(*AgentConfig)(nil),           // 13: manager.AgentConfig
-	(*timestamppb.Timestamp)(nil), // 14: google.protobuf.Timestamp
+	(*RunReqChunks)(nil),          // 8: manager.RunReqChunks
+	(*ComputationRunReq)(nil),     // 9: manager.ComputationRunReq
+	(*BackendInfoReq)(nil),        // 10: manager.BackendInfoReq
+	(*ResultConsumer)(nil),        // 11: manager.ResultConsumer
+	(*Dataset)(nil),               // 12: manager.Dataset
+	(*Algorithm)(nil),             // 13: manager.Algorithm
+	(*AgentConfig)(nil),           // 14: manager.AgentConfig
+	(*timestamppb.Timestamp)(nil), // 15: google.protobuf.Timestamp
 }
 var file_manager_manager_proto_depIdxs = []int32{
-	14, // 0: manager.AgentEvent.timestamp:type_name -> google.protobuf.Timestamp
-	14, // 1: manager.AgentLog.timestamp:type_name -> google.protobuf.Timestamp
+	15, // 0: manager.AgentEvent.timestamp:type_name -> google.protobuf.Timestamp
+	15, // 1: manager.AgentLog.timestamp:type_name -> google.protobuf.Timestamp
 	5,  // 2: manager.ClientStreamMessage.agent_log:type_name -> manager.AgentLog
 	4,  // 3: manager.ClientStreamMessage.agent_event:type_name -> manager.AgentEvent
 	2,  // 4: manager.ClientStreamMessage.run_res:type_name -> manager.RunResponse
 	3,  // 5: manager.ClientStreamMessage.backendInfo:type_name -> manager.BackendInfo
-	8,  // 6: manager.ServerStreamMessage.runReq:type_name -> manager.ComputationRunReq
-	0,  // 7: manager.ServerStreamMessage.terminateReq:type_name -> manager.Terminate
-	1,  // 8: manager.ServerStreamMessage.stopComputation:type_name -> manager.StopComputation
-	9,  // 9: manager.ServerStreamMessage.backendInfoReq:type_name -> manager.BackendInfoReq
-	11, // 10: manager.ComputationRunReq.datasets:type_name -> manager.Dataset
-	12, // 11: manager.ComputationRunReq.algorithm:type_name -> manager.Algorithm
-	10, // 12: manager.ComputationRunReq.result_consumers:type_name -> manager.ResultConsumer
-	13, // 13: manager.ComputationRunReq.agent_config:type_name -> manager.AgentConfig
-	6,  // 14: manager.ManagerService.Process:input_type -> manager.ClientStreamMessage
-	7,  // 15: manager.ManagerService.Process:output_type -> manager.ServerStreamMessage
-	15, // [15:16] is the sub-list for method output_type
-	14, // [14:15] is the sub-list for method input_type
-	14, // [14:14] is the sub-list for extension type_name
-	14, // [14:14] is the sub-list for extension extendee
-	0,  // [0:14] is the sub-list for field type_name
+	8,  // 6: manager.ServerStreamMessage.runReqChunks:type_name -> manager.RunReqChunks
+	9,  // 7: manager.ServerStreamMessage.runReq:type_name -> manager.ComputationRunReq
+	0,  // 8: manager.ServerStreamMessage.terminateReq:type_name -> manager.Terminate
+	1,  // 9: manager.ServerStreamMessage.stopComputation:type_name -> manager.StopComputation
+	10, // 10: manager.ServerStreamMessage.backendInfoReq:type_name -> manager.BackendInfoReq
+	12, // 11: manager.ComputationRunReq.datasets:type_name -> manager.Dataset
+	13, // 12: manager.ComputationRunReq.algorithm:type_name -> manager.Algorithm
+	11, // 13: manager.ComputationRunReq.result_consumers:type_name -> manager.ResultConsumer
+	14, // 14: manager.ComputationRunReq.agent_config:type_name -> manager.AgentConfig
+	6,  // 15: manager.ManagerService.Process:input_type -> manager.ClientStreamMessage
+	7,  // 16: manager.ManagerService.Process:output_type -> manager.ServerStreamMessage
+	16, // [16:17] is the sub-list for method output_type
+	15, // [15:16] is the sub-list for method input_type
+	15, // [15:15] is the sub-list for extension type_name
+	15, // [15:15] is the sub-list for extension extendee
+	0,  // [0:15] is the sub-list for field type_name
 }
 
 func init() { file_manager_manager_proto_init() }
@@ -1299,7 +1368,7 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[8].Exporter = func(v any, i int) any {
-			switch v := v.(*ComputationRunReq); i {
+			switch v := v.(*RunReqChunks); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1311,7 +1380,7 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[9].Exporter = func(v any, i int) any {
-			switch v := v.(*BackendInfoReq); i {
+			switch v := v.(*ComputationRunReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1323,7 +1392,7 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[10].Exporter = func(v any, i int) any {
-			switch v := v.(*ResultConsumer); i {
+			switch v := v.(*BackendInfoReq); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1335,7 +1404,7 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[11].Exporter = func(v any, i int) any {
-			switch v := v.(*Dataset); i {
+			switch v := v.(*ResultConsumer); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1347,7 +1416,7 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[12].Exporter = func(v any, i int) any {
-			switch v := v.(*Algorithm); i {
+			switch v := v.(*Dataset); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1359,6 +1428,18 @@ func file_manager_manager_proto_init() {
 			}
 		}
 		file_manager_manager_proto_msgTypes[13].Exporter = func(v any, i int) any {
+			switch v := v.(*Algorithm); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_manager_manager_proto_msgTypes[14].Exporter = func(v any, i int) any {
 			switch v := v.(*AgentConfig); i {
 			case 0:
 				return &v.state
@@ -1378,6 +1459,7 @@ func file_manager_manager_proto_init() {
 		(*ClientStreamMessage_BackendInfo)(nil),
 	}
 	file_manager_manager_proto_msgTypes[7].OneofWrappers = []any{
+		(*ServerStreamMessage_RunReqChunks)(nil),
 		(*ServerStreamMessage_RunReq)(nil),
 		(*ServerStreamMessage_TerminateReq)(nil),
 		(*ServerStreamMessage_StopComputation)(nil),
@@ -1389,7 +1471,7 @@ func file_manager_manager_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_manager_manager_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   14,
+			NumMessages:   15,
 			NumExtensions: 0,
 			NumServices:   1,
 		},