diff --git a/docs/commands.md b/docs/commands.md
index 29a02ed59..e79b3fafb 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -408,7 +408,55 @@ redis> > AI._MODELSCAN
    2) imagenet:5.0
 ```
 
+
+## AI.SCRIPTSTORE
+The **`AI.SCRIPTSTORE`** command stores a [TorchScript](https://pytorch.org/docs/stable/jit.html) as the value of a key.
+
+**Redis API**
+
+```
+AI.SCRIPTSTORE <key> <device> [TAG tag] ENTRY_POINTS <entry_point_amoint> <entry_point> [<entry_point>...] SOURCE "<script>"
+```
+
+_Arguments_
+
+
+* **key**: the script's key name
+* **TAG**: an optional string for tagging the script such as a version number or any arbitrary identifier
+* **device**: the device that will execute the model can be of:
+    * **CPU**: a CPU device
+    * **GPU**: a GPU device
+    * **GPU:0**, ..., **GPU:n**: a specific GPU device on a multi-GPU system
+* **ENTRY_POINTS** A list of entry points to be used in the script. Each entry point should have the signature of `def entry_point(tensors: List[Tensor], keys: List[str], args: List[str])`. The purpose of each list is as follows:
+* `tensors`: A list holding the input tensors to the function.
+* `keys`: A list of keys that the torch script is about to preform read/write operations on.
+* `args`: A list of additional arguments to the function. If the desired argument is not from type string, it is up to the caller to cast it to the right type, within the script.
+* **script**: a string containing [TorchScript](https://pytorch.org/docs/stable/jit.html) source code
+
+_Return_
+
+A simple 'OK' string or an error.
+
+**Examples**
+
+Given the following contents of the file 'addtwo.py':
+
+```python
+def addtwo(tensors: List[Tensor], keys: List[str], args: List[str]):
+    a = tensors[0]
+    b = tensors[1]
+    return a + b
+```
+
+It can be stored as a RedisAI script using the CPU device with [`redis-cli`](https://redis.io/topics/rediscli) as follows:
+
+```
+$ cat addtwo.py | redis-cli -x AI.SCRIPTSET myscript CPU TAG myscript:v0.1 ENTRY_POINTS 1 addtwo SOURCE
+OK
+```
+
 ## AI.SCRIPTSET
+_This command is deprecated and will not be available in future versions. consider using AI.SCRIPTSTORE command instead._
 The **`AI.SCRIPTSET`** command stores a [TorchScript](https://pytorch.org/docs/stable/jit.html) as the value of a key.
 
 **Redis API**
@@ -471,8 +519,9 @@ An array with alternating entries that represent the following key-value pairs:
 !!!!The command returns a list of key-value strings, namely `DEVICE device TAG tag [SOURCE source]`.
 
 1. **DEVICE**: the script's device as a String
-1. **TAG**: the scripts's tag as a String
-1. **SOURCE**: the script's source code as a String
+2. **TAG**: the scripts's tag as a String
+3. **SOURCE**: the script's source code as a String
+4. **ENTRY_POINTS** will return an array containing the script entry points
 
 **Examples**
 
@@ -487,6 +536,8 @@ redis> AI.SCRIPTGET myscript
 5) "source"
 6) def addtwo(a, b):
     return a + b
+7) "Entry Points"
+8) 1) addtwo
 ```
 
 ## AI.SCRIPTDEL
@@ -519,7 +570,7 @@ OK
 
 ## AI.SCRIPTEXECUTE
 
-The **`AI.SCRIPTEXECUTE`** command runs a script stored as a key's value on its specified device. It accepts one or more inputs, where the inputs could be tensors stored in RedisAI, int, float, or strings and stores the script outputs as RedisAI tensors if required.
+The **`AI.SCRIPTEXECUTE`** command runs a script stored as a key's value on its specified device. It a list of keys, input tensors and addtional script args.
 
 The run request is put in a queue and is executed asynchronously by a worker thread. The client that had issued the run request is blocked until the script run is completed. When needed, tensors data is automatically copied to the device prior to execution.
 
@@ -532,8 +583,9 @@ A `TIMEOUT t` argument can be specified to cause a request to be removed from th
 
 ```
 AI.SCRIPTEXECUTE <key> <function> 
-KEYS n <key> [keys...] 
-[INPUTS m <input> [input ...] | [LIST_INPUTS l <input> [input ...]]*]
+[KEYS n <key> [keys...]]
+[INPUTS m <input> [input ...]]
+[ARGS k <arg> [arg...]]
 [OUTPUTS k <output> [output ...] [TIMEOUT t]]+
 ```
 
@@ -541,13 +593,16 @@ _Arguments_
 
 * **key**: the script's key name
 * **function**: the name of the function to run
-* **KEYS**: Either a squence of key names that the script will access before, during and after its execution, or a tag which all those keys share. `KEYS` is a mandatory scope in this command. Redis will verify that all potional key accesses are done to the right shard.
-* **INPUTS**: Denotes the beginning of the input parameters list, followed by its length and one or more inputs; The inputs can be tensor key name, `string`, `int` or `float`. The order of the input should be aligned with the order of their respected parameter at the function signature. Note that list inputs are treated in the **LIST_INPUTS** scope.
-* **LIST_INPUTS** Denotes the beginning of a list, followed by its length and one or more inputs; The inputs can be tensor key name, `string`, `int` or `float`. The order of the input should be aligned with the order of their respected parameter at the function signature. Note that if more than one list is provided, their order should be aligned with the order of their respected paramter at the function signature.
+* **KEYS**: Either a squence of key names that the script will access before, during and after its execution, or a tag which all those keys share. 
+* **INPUTS**: Denotes the beginning of the input parameters list, followed by its length and one or more input tensors.
+* **ARGS**: A list additional arguments that a user can send to the script. All args are sent as strings, but can be casted to other types supported by torch script, such as `int`, or `float`. 
 
 * **OUTPUTS**: denotes the beginning of the output tensors keys' list, followed by its length and one or more key names.
 * **TIMEOUT**: the time (in ms) after which the client is unblocked and a `TIMEDOUT` string is returned
 
+Note:
+Either `KEYS` or `INPUTS` scopes should be provided this command (one or both scopes are acceptable). Those scopes indicate keyspace access and such, the right shard to execute the command at. Redis will verify that all potional key accesses are done to the right shard.
+
 _Return_
 
 A simple 'OK' string, a simple `TIMEDOUT` string, or an error.
@@ -584,10 +639,10 @@ redis> AI.TENSORGET result{tag} VALUES
 3) 1) "42"
 ```
 
-If 'myscript' supports `List[Tensor]` arguments:
+An example that supports `List[Tensor]` arguments:
 ```python
-def addn(a, args : List[Tensor]):
-    return a + torch.stack(args).sum()
+def addn(tensors: List[Tensor], keys: List[str], args: List[str]):
+    return torch.stack(tensors).sum()
 ```
 
 ```
@@ -597,7 +652,7 @@ redis> AI.TENSORSET mytensor2{tag} FLOAT 1 VALUES 1
 OK
 redis> AI.TENSORSET mytensor3{tag} FLOAT 1 VALUES 1
 OK
-redis> AI.SCRIPTEXECUTE myscript{tag} addn keys 1 {tag} INPUTS 1 mytensor1{tag} LIST_INPUTS 2 mytensor2{tag} mytensor3{tag} OUTPUTS 1 result{tag}
+redis> AI.SCRIPTEXECUTE myscript{tag} addn keys 1 {tag} INPUTS 3 mytensor1{tag} mytensor2{tag} mytensor3{tag} OUTPUTS 1 result{tag}
 OK
 redis> AI.TENSORGET result{tag} VALUES
 1) FLOAT
@@ -605,20 +660,24 @@ redis> AI.TENSORGET result{tag} VALUES
 3) 1) "42"
 ```
 
+Note: for the time being, as `AI.SCRIPTSET` is still avialable to use, `AI.SCRIPTEXECUTE` still supports running functions that are part of scripts stored with `AI.SCRIPTSET` or imported from old RDB/AOF files. Meaning calling `AI.SCRIPTEXECUTE` over a function without the dedicated signature of `(tensors: List[Tensor], keys: List[str], args: List[str]` will yield a "best effort" execution to match the deprecated API `AI.SCRIPTRUN` function execution. This will map `INPUTS` tensors only, to their counterpart input arguments in the function, according to the order which they apear.
+
 ### Redis Commands support.
-RedisAI TorchScript now supports simple (non-blocking) Redis commands via the `redis.execute` API. The following (useless) script gets a key name (`x{1}`), and an `int` value (3). First, the script `SET`s the value in the key. Next, the script `GET`s the value back from the key, and sets it in a tensor which is eventually stored under the key 'y{1}'. Note that the inputs are `str` and `int`. The script sets and gets the value and set it into a tensor.
+In RedisAI TorchScript now supports simple (non-blocking) Redis commnands via the `redis.execute` API. The following script gets a key name (`x{1}`), and an `int` value (3). First, the script `SET`s the value in the key. Next, the script `GET`s the value back from the key, and sets it in a tensor which is eventually stored under the key 'y{1}'. Note that the inputs are `str` and `int`. The script sets and gets the value and set it into a tensor.
 
 ```
 def redis_int_to_tensor(redis_value: int):
     return torch.tensor(redis_value)
 
-def int_set_get(key:str, value:int):
-    redis.execute("SET", key, str(value))
+def int_set_get(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    value = args[0]
+    redis.execute("SET", key, value)
     res = redis.execute("GET", key)
     return redis_string_int_to_tensor(res)
 ```
 ```
-redis> AI.SCRIPTEXECUTE redis_scripts{1} int_set_get KEYS 1 {1} INPUTS 2 x{1} 3 OUTPUTS 1 y{1}
+redis> AI.SCRIPTEXECUTE redis_scripts{1} int_set_get KEYS 1 x{1} ARGS 1 3 OUTPUTS 1 y{1}
 OK
 redis> AI.TENSORGET y{1} VALUES
 1) (integer) 3
@@ -764,7 +823,7 @@ It accepts one or more operations, split by the pipe-forward operator (`|>`).
 
 By default, the DAG execution context is local, meaning that tensor keys appearing in the DAG only live in the scope of the command. That is, setting a tensor with `TENSORSET` will store it local memory and not set it to an actual database key. One can refer to that key in subsequent commands within the DAG, but that key won't be visible outside the DAG or to other clients - no keys are open at the database level.
 
-Loading and persisting tensors from/to keyspace should be done explicitly. The user should specify which key tensors to load from keyspace using the `LOAD` keyword, and which command outputs to persist to the keyspace using the `PERSIST` keyspace. The user can also specify keys in Redis that are going to be accessed for read/write operations (for example, from within `AI.SCRIPTEXECUTE` command), by using the keyword `KEYS`.  
+Loading and persisting tensors from/to keyspace should be done explicitly. The user should specify which key tensors to load from keyspace using the `LOAD` keyword, and which command outputs to persist to the keyspace using the `PERSIST` keyspace. The user can also specify a tag or key which will assist for the routing of the DAG execution on the right shard in Redis that are going to be accessed for read/write operations (for example, from within `AI.SCRIPTEXECUTE` command), by using the keyword `ROUTING`.  
 
 As an example, if `command 1` sets a tensor, it can be referenced by any further command on the chaining.
 
@@ -776,7 +835,7 @@ A `TIMEOUT t` argument can be specified to cause a request to be removed from th
 ```
 AI.DAGEXECUTE [[LOAD <n> <key-1> <key-2> ... <key-n>] |
           [PERSIST <n> <key-1> <key-2> ... <key-n>] |
-          [KEYS <n> <key-1> <key-2> ... <key-n>]]+
+          [ROUTING <routing_tag>]]
           [TIMEOUT t]
           |> <command> [|>  command ...]
 ```
@@ -785,9 +844,9 @@ _Arguments_
 
 * **LOAD**: denotes the beginning of the input tensors keys' list, followed by the number of keys, and one or more key names
 * **PERSIST**: denotes the beginning of the output tensors keys' list, followed by the number of keys, and one or more key names
-* **KEYS**: denotes the beginning of keys' list which are used within this command, followed by the number of keys, and one or more key names. Alternately, the keys names list can be replaced with a tag which all of those keys share. Redis will verify that all potential key accesses are done to the right shard.
+* **ROUTING**: denotes the a key name or a tag that will assist in routing the dag execution command to the right shard. Redis will verify that all potential key accesses are done to within the target shard.
 
-_While each of the LOAD, PERSIST and KEYS sections are optional (and may appear at most once in the command), the command must contain **at least one** of these 3 keywords._
+_While each of the LOAD, PERSIST and ROUTING sections are optional (and may appear at most once in the command), the command must contain **at least one** of these 3 keywords._
 * **TIMEOUT**: an optional argument, denotes the time (in ms) after which the client is unblocked and a `TIMEDOUT` string is returned
 * **|> command**: the chaining operator, that denotes the beginning of a RedisAI command, followed by one of RedisAI's commands. Command splitting is done by the presence of another `|>`. The supported commands are:
     * `AI.TENSORSET`
@@ -817,9 +876,9 @@ redis> AI.DAGEXECUTE PERSIST 1 predictions{tag} |>
 1) OK
 2) OK
 3) 1) FLOAT
-   2) 1) (integer) 2
-      2) (integer) 2
-   3) "\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@"
+   1) 1) (integer) 2
+      1) (integer) 2
+   2) "\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@"
 ```
 
 A common pattern is enqueuing multiple SCRIPTEXECUTE and MODELEXECUTE commands within a DAG. The following example uses ResNet-50,to classify images into 1000 object categories. Given that our input tensor contains each color represented as a 8-bit integer and that neural networks usually work with floating-point tensors as their input we need to cast a tensor to floating-point and normalize the values of the pixels - for that we will use `pre_process_3ch` function. 
@@ -827,7 +886,7 @@ A common pattern is enqueuing multiple SCRIPTEXECUTE and MODELEXECUTE commands w
 To optimize the classification process we can use a post process script to return only the category position with the maximum classification - for that we will use `post_process` script. Using the DAG capabilities we've removed the necessity of storing the intermediate tensors in the keyspace. You can even run the entire process without storing the output tensor, as follows:
 
 ```
-redis> AI.DAGEXECUTE KEYS 1 {tag} |> 
+redis> AI.DAGEXECUTE ROUTING {tag} |> 
             AI.TENSORSET image UINT8 224 224 3 BLOB b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00....' |> 
             AI.SCRIPTEXECUTE imagenet_script{tag} pre_process_3ch INPUTS 1 image OUTPUTS 1 temp_key1 |> 
             AI.MODELEXECUTE imagenet_model{tag} INPUTS 1 temp_key1 OUTPUTS 1 temp_key2 |> 
diff --git a/src/backends/backends.c b/src/backends/backends.c
index c15cd8ea4..02a17bcf8 100644
--- a/src/backends/backends.c
+++ b/src/backends/backends.c
@@ -316,8 +316,9 @@ int RAI_LoadBackend_Torch(RedisModuleCtx *ctx, const char *path) {
         goto error;
     }
 
-    backend.script_create = (RAI_Script * (*)(const char *, const char *, RAI_Error *))(
-        unsigned long)dlsym(handle, "RAI_ScriptCreateTorch");
+    backend.script_create =
+        (RAI_Script * (*)(const char *, const char *, const char **, size_t, RAI_Error *))(
+            unsigned long)dlsym(handle, "RAI_ScriptCreateTorch");
     if (!_ValidateFuncExists(ctx, backend.script_create, "RAI_ScriptCreateTorch", "TORCH", path)) {
         goto error;
     }
diff --git a/src/backends/backends.h b/src/backends/backends.h
index 0345f8c04..6cb8b2ef3 100644
--- a/src/backends/backends.h
+++ b/src/backends/backends.h
@@ -64,7 +64,7 @@ typedef struct RAI_LoadedBackend {
     int (*model_serialize)(RAI_Model *, char **, size_t *, RAI_Error *);
 
     // ** script_create **:  A callback function pointer that creates a script
-    RAI_Script *(*script_create)(const char *, const char *, RAI_Error *);
+    RAI_Script *(*script_create)(const char *, const char *, const char **, size_t, RAI_Error *);
 
     // ** script_free **:  A callback function pointer that frees a script given
     // the RAI_Script pointer
diff --git a/src/backends/libtorch_c/torch_c.cpp b/src/backends/libtorch_c/torch_c.cpp
index 930abec90..b483fe750 100644
--- a/src/backends/libtorch_c/torch_c.cpp
+++ b/src/backends/libtorch_c/torch_c.cpp
@@ -353,88 +353,8 @@ static torch::DeviceType getDeviceType(ModuleContext *ctx) {
     }
 }
 
-extern "C" bool torchMatchScriptSchema(TorchScriptFunctionArgumentType *schema ,size_t nArguments, TorchFunctionInputCtx* inputsCtx, char **error) {
-    char* buf; 
-    int schemaListCount = 0;
-    size_t schemaTensorCount = 0;
-    size_t schemaIntCount = 0;
-    size_t schemaFloatCount = 0;
-    size_t schemaStringCount = 0;
-    size_t totalInputsCount = inputsCtx->tensorCount + inputsCtx->intCount + inputsCtx->floatCount + inputsCtx->stringCount;
-    if((totalInputsCount) < nArguments) {
-        asprintf(&buf, "Wrong number of inputs. Expected %ld but was %ld", nArguments, totalInputsCount);
-        goto cleanup;
-    }
-    for (size_t i = 0; i < nArguments; i++) {
-        switch (schema[i]) {
-            case TENSOR:
-                schemaTensorCount++;
-                break;
-            case INT:
-                schemaIntCount++;
-                break;
-            case FLOAT:
-                schemaFloatCount++;
-                break;
-            case STRING:
-                schemaStringCount++;
-                break;
-            case TENSOR_LIST:
-                schemaListCount++;
-                if(schemaListCount > inputsCtx->listCount) {
-                     asprintf(&buf, "Wrong number of lists. Expected %d but was %ld", schemaListCount, inputsCtx->listCount);
-                     goto cleanup;
-                }
-                schemaTensorCount+=inputsCtx->listSizes[schemaListCount-1];
-                break;
-            case INT_LIST:
-                schemaListCount++;
-                if(schemaListCount > inputsCtx->listCount) {
-                     asprintf(&buf, "Wrong number of lists. Expected %d but was %ld", schemaListCount, inputsCtx->listCount);
-                     goto cleanup;
-                }
-                schemaIntCount+=inputsCtx->listSizes[schemaListCount-1];
-                break;
-            case FLOAT_LIST:
-                schemaListCount++;
-                if(schemaListCount > inputsCtx->listCount) {
-                     asprintf(&buf, "Wrong number of lists. Expected %d but was %ld", schemaListCount, inputsCtx->listCount);
-                     goto cleanup;
-                }
-                schemaFloatCount+=inputsCtx->listSizes[schemaListCount-1];
-                break;
-            case STRING_LIST:
-                schemaListCount++;
-                if(schemaListCount > inputsCtx->listCount) {
-                     asprintf(&buf, "Wrong number of lists. Expected %d but was %ld", schemaListCount, inputsCtx->listCount);
-                     goto cleanup;
-                }
-                schemaStringCount+=inputsCtx->listSizes[schemaListCount-1];
-                break;
-            default:
-                asprintf(&buf, "Unkown type in script schema validation.");
-                goto cleanup;
-        }
-    } 
-    if(schemaListCount != inputsCtx->listCount) {
-        asprintf(&buf, "Wrong number of lists. Expected %d but was %ld", schemaListCount, inputsCtx->listCount);
-        goto cleanup;
-    }
-    if(schemaTensorCount != inputsCtx->tensorCount || schemaIntCount != inputsCtx->intCount || schemaFloatCount != inputsCtx->floatCount || schemaStringCount!= inputsCtx->stringCount) {
-        asprintf(&buf, "Wrong number of parameters");
-        goto cleanup;
-    }
-
-    return true;
-
-    cleanup:
-    *error = RedisModule_Strdup(buf);
-    free(buf);
-    return false;
-}
 
 extern "C" void torchRunScript(void *scriptCtx, const char *fnName,
-                                TorchScriptFunctionArgumentType* schema, size_t nArguments,
                                 TorchFunctionInputCtx* inputsCtx,
                                 DLManagedTensor **outputs,long nOutputs,
                                 char **error) {
@@ -444,87 +364,73 @@ extern "C" void torchRunScript(void *scriptCtx, const char *fnName,
         torch::Device device(device_type, ctx->device_id);
 
         torch::jit::Stack stack;
-
-        size_t listsIdx = 0;
-        size_t tensorIdx = 0;
-        size_t intIdx = 0;
-        size_t floatIdx = 0;
-        size_t stringIdx = 0;
-        for(size_t i= 0; i < nArguments; i++) {
-            // In case of tensor.
-            switch (schema[i]) {
-                case TENSOR: {
-                    DLTensor *input = &(inputsCtx->tensorInputs[tensorIdx++]->dl_tensor);
-                    torch::Tensor tensor = fromDLPack(input);
-                    stack.push_back(tensor.to(device));
-                    break;
+        if(!inputsCtx->hasEntryPoint) {
+            /* In case of no entry point, this might be due to a usage in a script set by the deprecated API.
+             * In this case, until SCRIPTSET is EOL we will allow functions, called by SCRIPTRUN or SCRIPTEXECUTE, and those
+             * functions are not in the endpoint set to be executed in "best effort" manner.
+             */
+            if(!torchScript_FunctionExists(ctx, fnName)) {
+                throw std::runtime_error(std::string("Function does not exist: ") + fnName);
+            }
+            size_t nArgs = torchScript_FunctionArgumentCountByFunctionName(ctx, fnName);
+            if(nArgs > inputsCtx->tensorCount) {
+                throw std::runtime_error(std::string("Wrong number of inputs provided to function: ") + fnName);
+            }
+            for (size_t i= 0; i < nArgs; i++) {
+                TorchScriptFunctionArgumentType argType =  torchScript_FunctionArgumentTypeByFunctionName(ctx, fnName, i);
+                // Argument can be either a tensor or a tensor list.
+                if((argType!= TENSOR && argType != TENSOR_LIST)) {
+                    throw std::runtime_error(std::string("Unsupported input type in function definition: ") + fnName);
                 }
-                case TENSOR_LIST: {
-                    std::vector<torch::Tensor> args;
-                    size_t argumentSize = inputsCtx->listSizes[listsIdx++];
-                    for (size_t j = 0; j < argumentSize; j++) {
-                        DLTensor *input = &(inputsCtx->tensorInputs[tensorIdx++]->dl_tensor);
+                if(argType == TENSOR) {
+                    // In case of tensor
+                    DLTensor *input = &(inputsCtx->tensorInputs[i]->dl_tensor);
+                    torch::Tensor tensor = fromDLPack(input);
+                    tensor.to(device);
+                    stack.push_back(tensor);
+                } else {
+                    // In case of a tensor list, this is the last argument, add all tensors and break.
+                    std::vector<torch::Tensor> tensors;
+                    for (size_t j = i; j < inputsCtx->tensorCount; j++) {
+                        DLTensor *input = &(inputsCtx->tensorInputs[j]->dl_tensor);
                         torch::Tensor tensor = fromDLPack(input);
                         tensor.to(device);
-                        args.emplace_back(tensor);
-                    }
-                    stack.push_back(args);
-                    break;
-                }
-                case STRING_LIST: {
-                    std::vector<torch::string> args;
-                    size_t argumentSize = inputsCtx->listSizes[listsIdx++];
-                    for (size_t j = 0; j < argumentSize; j++) {
-                        const char* cstr = RedisModule_StringPtrLen(inputsCtx->stringsInputs[stringIdx++], NULL);
-                        torch::string str = torch::string(cstr);
-                        args.emplace_back(str);
-                    }
-                    stack.push_back(args);
-                    break;
-                }
-                case INT_LIST: {
-                    std::vector<int> args;
-                    size_t argumentSize = inputsCtx->listSizes[listsIdx++];
-                    for (size_t j = 0; j < argumentSize; j++) {
-                        int32_t val = inputsCtx->intInputs[intIdx++];
-                        args.emplace_back(val);
-                    }
-                    stack.push_back(args);
-                    break;
-                }
-                case FLOAT_LIST: {
-                    std::vector<float> args;
-                    size_t argumentSize = inputsCtx->listSizes[listsIdx++];
-                    for (size_t j = 0; j < argumentSize; j++) {
-                        float val = inputsCtx->floatInputs[floatIdx++];
-                        args.emplace_back(val);
+                        tensors.emplace_back(tensor);
                     }
-                    stack.push_back(args);
-                    break;
-                }
-
-                case INT: {
-                    int32_t val = inputsCtx->intInputs[intIdx++];
-                    stack.push_back(val);
-                    break;
-                }
-                case FLOAT: {
-                    float val = inputsCtx->floatInputs[floatIdx++];
-                    stack.push_back(val);
-                    break;
-                }
-                case STRING: {
-                    const char* cstr = RedisModule_StringPtrLen(inputsCtx->stringsInputs[stringIdx++], NULL);
-                    torch::string str = torch::string(cstr);
-                    stack.push_back(str);
-                    break;
-                }
-                default: {
-                    *error = RedisModule_Strdup("Unkown script input type");
+                    stack.push_back(tensors);
                     break;
                 }
             }
         }
+        else {
+        std::vector<torch::Tensor> tensors;
+        for (size_t i = 0; i < inputsCtx->tensorCount; i++) {
+            DLTensor *input = &(inputsCtx->tensorInputs[i]->dl_tensor);
+            torch::Tensor tensor = fromDLPack(input);
+            tensor.to(device);
+            tensors.emplace_back(tensor);
+        }
+        stack.push_back(tensors);
+
+        std::vector<torch::string> keys;
+        for(size_t i=0; i < inputsCtx->keysCount; i++) {
+            size_t len;
+            const char* cstr = RedisModule_StringPtrLen(inputsCtx->keys[i], &len);
+            torch::string str = torch::string(cstr);
+            keys.emplace_back(str);
+        }
+        stack.push_back(keys);
+
+        std::vector<torch::string> args;
+        for(size_t i=0; i < inputsCtx->argsCount; i++) {
+            size_t len;
+            const char* cstr = RedisModule_StringPtrLen(inputsCtx->args[i], &len);
+            torch::string str = torch::string(cstr);
+            args.emplace_back(str);
+        }
+        stack.push_back(args);
+        }
+
 
         torchRunModule(ctx, fnName, stack, nOutputs, outputs);
     } catch (std::exception &e) {
@@ -707,14 +613,21 @@ extern "C" const char* torchScript_FunctionName(void* scriptCtx, size_t fn_index
     return functions[fn_index]->name().c_str();
 }
 
-extern "C" size_t torchScript_FunctionArgumentCount(void* scriptCtx, size_t fn_index) {
+extern "C" size_t torchScript_FunctionArgumentCountByFunctionName(void *scriptCtx, const char* functionName) {
     ModuleContext *ctx = (ModuleContext *)scriptCtx;
-    std::vector<torch::jit::Function*> functions = ctx->cu->get_functions();
-    return functions[fn_index]->getSchema().arguments().size();
+    torch::jit::Function* function = ctx->cu->find_function(functionName);
+    return function->getSchema().arguments().size();
 }
 
-extern "C" TorchScriptFunctionArgumentType torchScript_FunctionArgumentype(void* scriptCtx, size_t fn_index, size_t arg_index) {
+extern "C" TorchScriptFunctionArgumentType torchScript_FunctionArgumentTypeByFunctionName(void *scriptCtx, const char* functionName,
+                                                                size_t arg_index) {
     ModuleContext *ctx = (ModuleContext *)scriptCtx;
-    std::vector<torch::jit::Function*> functions = ctx->cu->get_functions();
-    return getArgumentType(ctx->cu->get_functions()[fn_index]->getSchema().arguments()[arg_index]);
+    torch::jit::Function* function = ctx->cu->find_function(functionName);
+    return getArgumentType(function->getSchema().arguments()[arg_index]);
+}
+
+extern "C" bool torchScript_FunctionExists(void *scriptCtx, const char* functionName) {
+    ModuleContext *ctx = (ModuleContext *)scriptCtx;
+    torch::jit::Function* function = ctx->cu->find_function(functionName);
+    return function!=nullptr;
 }
diff --git a/src/backends/libtorch_c/torch_c.h b/src/backends/libtorch_c/torch_c.h
index 18aa1cb64..c46f0b12f 100644
--- a/src/backends/libtorch_c/torch_c.h
+++ b/src/backends/libtorch_c/torch_c.h
@@ -11,14 +11,13 @@ extern "C" {
 typedef struct TorchFunctionInputCtx {
     DLManagedTensor **tensorInputs;
     size_t tensorCount;
-    int32_t *intInputs;
-    size_t intCount;
-    float *floatInputs;
-    size_t floatCount;
-    RedisModuleString **stringsInputs;
-    size_t stringCount;
-    size_t *listSizes;
-    size_t listCount;
+    RedisModuleString **args;
+    size_t argsCount;
+    RedisModuleString **keys;
+    size_t keysCount;
+    bool hasEntryPoint; // TODO: remove this when SCRIPTRUN is EOL. Indication that the script was
+                        // stored with SCRIPTSET and not SCRIPTSTORE, such that it has no entry
+                        // point, so execution is best effort.
 } TorchFunctionInputCtx;
 
 /**
@@ -45,34 +44,17 @@ void *torchCompileScript(const char *script, DLDeviceType device, int64_t device
 void *torchLoadModel(const char *model, size_t modellen, DLDeviceType device, int64_t device_id,
                      char **error);
 
-/**
- * @brief  Validate SCRIPTEXECUTE or LLAPI script execute inputs according to the funciton schema.
- *
- * @param schema Fuction argument types (schema).
- * @param nArguments Number of arguments in the function.
- * @param inputsCtx Function execution context containing the information about given inputs.
- * @param error Error string to be populated in case of an exception.
- * @return true If the user provided inputs from types and order that matches the schema.
- * @return false Otherwise.
- */
-bool torchMatchScriptSchema(TorchScriptFunctionArgumentType *schema, size_t nArguments,
-                            TorchFunctionInputCtx *inputsCtx, char **error);
-
 /**
  * @brief Executes a function in a script.
- * @note Should be called after torchMatchScriptSchema verication.
  * @param scriptCtx Executes a function in a script.
  * @param fnName Function name.
- * @param schema Fuction argument types (schema).
- * @param nArguments Number of arguments in the function.
  * @param inputsCtx unction execution context containing the information about given inputs.
  * @param outputs Array of output tensor (placeholders).
  * @param nOutputs Number of output tensors.
  * @param error Error string to be populated in case of an exception.
  */
-void torchRunScript(void *scriptCtx, const char *fnName, TorchScriptFunctionArgumentType *schema,
-                    size_t nArguments, TorchFunctionInputCtx *inputsCtx, DLManagedTensor **outputs,
-                    long nOutputs, char **error);
+void torchRunScript(void *scriptCtx, const char *fnName, TorchFunctionInputCtx *inputsCtx,
+                    DLManagedTensor **outputs, long nOutputs, char **error);
 
 /**
  * @brief Executes a model.
@@ -166,25 +148,36 @@ size_t torchScript_FunctionCount(void *scriptCtx);
 const char *torchScript_FunctionName(void *scriptCtx, size_t fn_index);
 
 /**
- * @brief Return the number of arguments in the fuction numbered fn_index in the script.
+ * @brief Return the number of arguments of a given fuction in the script.
  *
  * @param scriptCtx Script context.
- * @param fn_index Function number.
+ * @param functionName Function name.
  * @return size_t Number of arguments.
  */
-size_t torchScript_FunctionArgumentCount(void *scriptCtx, size_t fn_index);
+size_t torchScript_FunctionArgumentCountByFunctionName(void *scriptCtx, const char *functionName);
 
 /**
- * @brief Rerturns the type of the argument at arg_index of function numbered fn_index in the
+ * @brief Returns the type of the argument at arg_index of a given function in the
  * script.
  *
  * @param scriptCtx Script context.
- * @param fn_index Function number.
+ * @param functionName Function name.
  * @param arg_index Argument number.
  * @return TorchScriptFunctionArgumentType The type of the argument in RedisAI enum format.
  */
-TorchScriptFunctionArgumentType torchScript_FunctionArgumentype(void *scriptCtx, size_t fn_index,
-                                                                size_t arg_index);
+TorchScriptFunctionArgumentType
+torchScript_FunctionArgumentTypeByFunctionName(void *scriptCtx, const char *functionName,
+                                               size_t arg_index);
+
+/**
+ * @brief Returns if function with a given name exists in the script
+ *
+ * @param scriptCtx Script context.
+ * @param functionName Function name.
+ * @return true If the function exists.
+ * @return false If the function does not exists.
+ */
+bool torchScript_FunctionExists(void *scriptCtx, const char *functionName);
 
 /**
  * @brief Creates a new dltensor representation from torch tensor, by taking
diff --git a/src/backends/torch.c b/src/backends/torch.c
index 25c49c25c..70d9e7d80 100644
--- a/src/backends/torch.c
+++ b/src/backends/torch.c
@@ -1,4 +1,6 @@
 #define REDISMODULE_MAIN
+#define _GNU_SOURCE
+#include <string.h>
 #include "backends/util.h"
 #include "backends/torch.h"
 #include "backends/backends_api.h"
@@ -309,7 +311,8 @@ int RAI_ModelSerializeTorch(RAI_Model *model, char **buffer, size_t *len, RAI_Er
     return 0;
 }
 
-RAI_Script *RAI_ScriptCreateTorch(const char *devicestr, const char *scriptdef, RAI_Error *error) {
+RAI_Script *RAI_ScriptCreateTorch(const char *devicestr, const char *scriptdef,
+                                  const char **entryPoints, size_t nEntryPoints, RAI_Error *error) {
     DLDeviceType dl_device;
 
     RAI_Device device;
@@ -341,34 +344,69 @@ RAI_Script *RAI_ScriptCreateTorch(const char *devicestr, const char *scriptdef,
         return NULL;
     }
 
+    // Entry points validation
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        const char *entryPoint = entryPoints[i];
+        // Existence check.
+        if (!torchScript_FunctionExists(script, entryPoint)) {
+            torchDeallocContext(script);
+            char *errMsg;
+            asprintf(&errMsg, "Function %s does not exist in the given script.", entryPoint);
+            RAI_SetError(error, RAI_ESCRIPTCREATE, errMsg);
+            free(errMsg);
+            return NULL;
+        }
+
+        // Check for number of arguments.
+        size_t argCount = torchScript_FunctionArgumentCountByFunctionName(script, entryPoint);
+        if (argCount != 3) {
+            torchDeallocContext(script);
+            char *errMsg;
+            asprintf(&errMsg, "Wrong number of inputs in function %s. Expected 3 but was %ld",
+                     entryPoint, argCount);
+            RAI_SetError(error, RAI_ESCRIPTCREATE, errMsg);
+            free(errMsg);
+            return NULL;
+        }
+
+        // Check for legal arguments.
+        TorchScriptFunctionArgumentType argType1 =
+            torchScript_FunctionArgumentTypeByFunctionName(script, entryPoint, 0);
+        TorchScriptFunctionArgumentType argType2 =
+            torchScript_FunctionArgumentTypeByFunctionName(script, entryPoint, 1);
+        TorchScriptFunctionArgumentType argType3 =
+            torchScript_FunctionArgumentTypeByFunctionName(script, entryPoint, 2);
+        if (argType1 != TENSOR_LIST || argType2 != STRING_LIST || argType3 != STRING_LIST) {
+            torchDeallocContext(script);
+            char *errMsg;
+            asprintf(&errMsg,
+                     "Wrong inputs type in function %s. Expected signature similar to: def "
+                     "%s(tensors: List[Tensor], keys: List[str], args: List[str])",
+                     entryPoint, entryPoint);
+            RAI_SetError(error, RAI_ESCRIPTCREATE, errMsg);
+            free(errMsg);
+            return NULL;
+        }
+    }
+
     RAI_Script *ret = RedisModule_Calloc(1, sizeof(*ret));
     ret->script = script;
     ret->scriptdef = RedisModule_Strdup(scriptdef);
     ret->devicestr = RedisModule_Strdup(devicestr);
     ret->refCount = 1;
-    ret->functionData = AI_dictCreate(&AI_dictType_String_ArrSimple, NULL);
-
-    size_t functionCount = torchScript_FunctionCount(script);
-    for (size_t i = 0; i < functionCount; i++) {
-        const char *name = torchScript_FunctionName(script, i);
-        size_t argCount = torchScript_FunctionArgumentCount(script, i);
-        TorchScriptFunctionArgumentType *argTypes =
-            array_new(TorchScriptFunctionArgumentType, argCount);
-        for (size_t j = 0; j < argCount; j++) {
-            TorchScriptFunctionArgumentType argType = torchScript_FunctionArgumentype(script, i, j);
-            argTypes = array_append(argTypes, argType);
-        }
-        AI_dictAdd(ret->functionData, (void *)name, (void *)argTypes);
-        array_free(argTypes);
+    ret->entryPoints = array_new(char *, nEntryPoints);
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        ret->entryPoints = array_append(ret->entryPoints, RedisModule_Strdup(entryPoints[i]));
     }
-
     return ret;
 }
 
 void RAI_ScriptFreeTorch(RAI_Script *script, RAI_Error *error) {
-
     torchDeallocContext(script->script);
-    AI_dictRelease(script->functionData);
+    for (size_t i = 0; i < array_len(script->entryPoints); i++) {
+        RedisModule_Free(script->entryPoints[i]);
+    }
+    array_free(script->entryPoints);
     RedisModule_Free(script->scriptdef);
     RedisModule_Free(script->devicestr);
     RedisModule_Free(script);
@@ -393,36 +431,27 @@ int RAI_ScriptRunTorch(RAI_Script *script, const char *function, RAI_ExecutionCt
 
     char *error_descr = NULL;
 
-    TorchScriptFunctionArgumentType *arguments = RAI_ScriptGetSignature(script, function);
-    if (!arguments) {
-        RAI_SetError(error, RAI_ESCRIPTRUN, "attempted to get undefined function");
-        RedisModule_Free(error_descr);
-        return 1;
-    }
-
     RAI_ScriptRunCtx *sctx = (RAI_ScriptRunCtx *)ectx;
 
-    // Create inputs context on stack.
-    TorchFunctionInputCtx inputsCtx = {0};
-    inputsCtx.tensorInputs = inputs;
-    inputsCtx.tensorCount = nInputs;
-    inputsCtx.intInputs = sctx->intInputs;
-    inputsCtx.intCount = array_len(sctx->intInputs);
-    inputsCtx.floatInputs = sctx->floatInputs;
-    inputsCtx.floatCount = array_len(sctx->floatInputs);
-    inputsCtx.stringsInputs = sctx->stringInputs;
-    inputsCtx.stringCount = array_len(sctx->stringInputs);
-    inputsCtx.listSizes = sctx->listSizes;
-    inputsCtx.listCount = array_len(sctx->listSizes);
-
-    if (!torchMatchScriptSchema(arguments, array_len(arguments), &inputsCtx, &error_descr)) {
-        RAI_SetError(error, RAI_ESCRIPTRUN, error_descr);
-        RedisModule_Free(error_descr);
-        return 1;
+    // TODO: remove when SCRIPTRUN is EOL.
+    bool hasEntryPoint = false;
+    for (size_t i = 0; i < array_len(script->entryPoints); i++) {
+        if (strcmp(function, script->entryPoints[i]) == 0) {
+            hasEntryPoint = true;
+            break;
+        }
     }
 
-    torchRunScript(script->script, function, arguments, array_len(arguments), &inputsCtx, outputs,
-                   nOutputs, &error_descr);
+    // Create inputs context on stack.
+    TorchFunctionInputCtx inputsCtx = {.tensorInputs = inputs,
+                                       .tensorCount = nInputs,
+                                       .args = sctx->args,
+                                       .argsCount = array_len(sctx->args),
+                                       .keys = sctx->keys,
+                                       .keysCount = array_len(sctx->keys),
+                                       .hasEntryPoint = hasEntryPoint};
+
+    torchRunScript(script->script, function, &inputsCtx, outputs, nOutputs, &error_descr);
 
     if (error_descr) {
         RAI_SetError(error, RAI_ESCRIPTRUN, error_descr);
diff --git a/src/backends/torch.h b/src/backends/torch.h
index 45448f237..886ab18d8 100644
--- a/src/backends/torch.h
+++ b/src/backends/torch.h
@@ -17,7 +17,9 @@ int RAI_ModelRunTorch(RAI_Model *model, RAI_ExecutionCtx **ectxs, RAI_Error *err
 
 int RAI_ModelSerializeTorch(RAI_Model *model, char **buffer, size_t *len, RAI_Error *error);
 
-RAI_Script *RAI_ScriptCreateTorch(const char *devicestr, const char *scriptdef, RAI_Error *error);
+RAI_Script *RAI_ScriptCreateTorch(const char *devicestr, const char *scriptdef,
+                                  const char **entry_points, size_t n_entry_points,
+                                  RAI_Error *error);
 
 void RAI_ScriptFreeTorch(RAI_Script *script, RAI_Error *error);
 
diff --git a/src/execution/DAG/dag.c b/src/execution/DAG/dag.c
index 5902e5438..f677315b7 100644
--- a/src/execution/DAG/dag.c
+++ b/src/execution/DAG/dag.c
@@ -667,8 +667,7 @@ int RedisAI_DagExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
     size_t argpos = 1;
     while (argpos < argc) {
         const char *arg_string = RedisModule_StringPtrLen(argv[argpos++], NULL);
-        if (!strcasecmp(arg_string, "LOAD") || !strcasecmp(arg_string, "PERSIST") ||
-            !strcasecmp(arg_string, "KEYS")) {
+        if (!strcasecmp(arg_string, "LOAD") || !strcasecmp(arg_string, "PERSIST")) {
             if (argpos >= argc) {
                 return REDISMODULE_ERR;
             }
@@ -684,6 +683,11 @@ int RedisAI_DagExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
             for (; argpos < last_argpos; argpos++) {
                 RedisModule_KeyAtPos(ctx, argpos);
             }
+        } else if (!strcasecmp(arg_string, "ROUTING")) {
+            if (argpos >= argc) {
+                return REDISMODULE_ERR;
+            }
+            RedisModule_KeyAtPos(ctx, argpos++);
         } else if (!strcasecmp(arg_string, "AI.MODELEXECUTE") ||
                    !strcasecmp(arg_string, "AI.SCRIPTEXECUTE")) {
             if (argpos >= argc) {
diff --git a/src/execution/execution_contexts/scriptRun_ctx.c b/src/execution/execution_contexts/scriptRun_ctx.c
index d052a8a24..6bf1eab68 100644
--- a/src/execution/execution_contexts/scriptRun_ctx.c
+++ b/src/execution/execution_contexts/scriptRun_ctx.c
@@ -12,10 +12,8 @@ RAI_ScriptRunCtx *RAI_ScriptRunCtxCreate(RAI_Script *script, const char *fnname)
     RAI_ExecutionCtx_Init(&sctx->base, (RAI_ExecutionCtx_Free_fn)RAI_ScriptRunCtxFree);
     sctx->script = RAI_ScriptGetShallowCopy(script);
     sctx->fnname = RedisModule_Strdup(fnname);
-    sctx->listSizes = array_new(size_t, PARAM_INITIAL_SIZE);
-    sctx->intInputs = array_new(int32_t, PARAM_INITIAL_SIZE);
-    sctx->floatInputs = array_new(float, PARAM_INITIAL_SIZE);
-    sctx->stringInputs = array_new(RedisModuleString *, PARAM_INITIAL_SIZE);
+    sctx->keys = array_new(RedisModuleString *, PARAM_INITIAL_SIZE);
+    sctx->args = array_new(RedisModuleString *, PARAM_INITIAL_SIZE);
     return sctx;
 }
 
@@ -32,7 +30,6 @@ int RAI_ScriptRunCtxAddInputList(RAI_ScriptRunCtx *sctx, RAI_Tensor **inputTenso
     for (size_t i = 0; i < len; i++) {
         RAI_ExecutionCtx_AddInput(&sctx->base, inputTensors[i]);
     }
-    sctx->listSizes = array_append(sctx->listSizes, len);
     return 1;
 }
 
@@ -41,26 +38,6 @@ int RAI_ScriptRunCtxAddTensorInput(RAI_ScriptRunCtx *sctx, RAI_Tensor *inputTens
     return 1;
 }
 
-int RAI_ScriptRunCtxAddIntInput(RAI_ScriptRunCtx *sctx, int32_t i) {
-    sctx->intInputs = array_append(sctx->intInputs, i);
-    return 1;
-}
-
-int RAI_ScriptRunCtxAddFloatInput(RAI_ScriptRunCtx *sctx, float f) {
-    sctx->floatInputs = array_append(sctx->floatInputs, f);
-    return 1;
-}
-
-int RAI_ScriptRunCtxAddRStringInput(RAI_ScriptRunCtx *sctx, RedisModuleString *s) {
-    sctx->stringInputs = array_append(sctx->stringInputs, RAI_HoldString(s));
-    return 1;
-}
-
-int RAI_ScriptRunCtxAddStringInput(RAI_ScriptRunCtx *sctx, const char *s, size_t len) {
-    RedisModuleString *rs = RedisModule_CreateString(NULL, s, len);
-    return RAI_ScriptRunCtxAddRStringInput(sctx, rs);
-}
-
 int RAI_ScriptRunCtxAddTensorInputList(RAI_ScriptRunCtx *sctx, RAI_Tensor **inputTensors,
                                        size_t count) {
     int res = 1;
@@ -70,42 +47,13 @@ int RAI_ScriptRunCtxAddTensorInputList(RAI_ScriptRunCtx *sctx, RAI_Tensor **inpu
     return res;
 }
 
-int RAI_ScriptRunCtxAddIntInputList(RAI_ScriptRunCtx *sctx, int32_t *intInputs, size_t count) {
-    int res = 1;
-    for (size_t i = 0; i < count; i++) {
-        res &= RAI_ScriptRunCtxAddIntInput(sctx, intInputs[i]);
-    }
-    return res;
-}
-
-int RAI_ScriptRunCtxAddFloatInputList(RAI_ScriptRunCtx *sctx, float *floatInputs, size_t count) {
-    int res = 1;
-    for (size_t i = 0; i < count; i++) {
-        res &= RAI_ScriptRunCtxAddFloatInput(sctx, floatInputs[i]);
-    }
-    return res;
-}
-
-int RAI_ScriptRunCtxAddRStringInputList(RAI_ScriptRunCtx *sctx, RedisModuleString **stringInputs,
-                                        size_t count) {
-    int res = 1;
-    for (size_t i = 0; i < count; i++) {
-        res &= RAI_ScriptRunCtxAddRStringInput(sctx, stringInputs[i]);
-    }
-    return res;
-}
-
-int RAI_ScriptRunCtxAddStringInputList(RAI_ScriptRunCtx *sctx, const char **stringInputs,
-                                       size_t *lens, size_t count) {
-    int res = 1;
-    for (size_t i = 0; i < count; i++) {
-        res &= RAI_ScriptRunCtxAddStringInput(sctx, stringInputs[i], lens[i]);
-    }
-    return res;
+int RAI_ScriptRunCtxAddKeyInput(RAI_ScriptRunCtx *sctx, RedisModuleString *key) {
+    sctx->keys = array_append(sctx->keys, key);
+    return 1;
 }
 
-inline int RAI_ScriptRunCtxAddListSize(RAI_ScriptRunCtx *sctx, size_t len) {
-    sctx->listSizes = array_append(sctx->listSizes, len);
+int RAI_ScriptRunCtxAddArgInput(RAI_ScriptRunCtx *sctx, RedisModuleString *arg) {
+    sctx->args = array_append(sctx->args, arg);
     return 1;
 }
 
@@ -124,14 +72,16 @@ RAI_Tensor *RAI_ScriptRunCtxOutputTensor(RAI_ScriptRunCtx *sctx, size_t index) {
 
 void RAI_ScriptRunCtxFree(RAI_ScriptRunCtx *sctx) {
     RAI_ExecutionCtx_Free((RAI_ExecutionCtx *)sctx);
-    for (size_t i = 0; i < array_len(sctx->stringInputs); ++i) {
-        RedisModule_FreeString(NULL, sctx->stringInputs[i]);
+    for (size_t i = 0; i < array_len(sctx->args); ++i) {
+        RedisModule_FreeString(NULL, sctx->args[i]);
+    }
+    array_free(sctx->args);
+
+    for (size_t i = 0; i < array_len(sctx->keys); ++i) {
+        RedisModule_FreeString(NULL, sctx->keys[i]);
     }
 
-    array_free(sctx->listSizes);
-    array_free(sctx->stringInputs);
-    array_free(sctx->intInputs);
-    array_free(sctx->floatInputs);
+    array_free(sctx->keys);
 
     RedisModule_Free(sctx->fnname);
 
@@ -182,14 +132,6 @@ int RAI_ScriptRunAsync(RAI_ScriptRunCtx *sctx, RAI_OnFinishCB ScriptAsyncFinish,
     return REDISMODULE_OK;
 }
 
-inline TorchScriptFunctionArgumentType *RAI_ScriptRunCtxGetSignature(RAI_ScriptRunCtx *sctx) {
-    return RAI_ScriptGetSignature(sctx->script, sctx->fnname);
-}
-
-size_t RAI_ScriptRunCtxGetInputListLen(RAI_ScriptRunCtx *sctx, size_t index) {
-    return sctx->listSizes[index];
-}
-
 int ScriptRunCtx_SetParams(RedisModuleCtx *ctx, RedisModuleString **inkeys,
                            RedisModuleString **outkeys, RAI_ScriptRunCtx *sctx, RAI_Error *err) {
 
diff --git a/src/execution/execution_contexts/scriptRun_ctx.h b/src/execution/execution_contexts/scriptRun_ctx.h
index 5309f014e..1ebaa12aa 100644
--- a/src/execution/execution_contexts/scriptRun_ctx.h
+++ b/src/execution/execution_contexts/scriptRun_ctx.h
@@ -6,10 +6,8 @@ typedef struct RAI_ScriptRunCtx {
     RAI_ExecutionCtx base;
     RAI_Script *script;
     char *fnname;
-    size_t *listSizes;
-    int32_t *intInputs;
-    float *floatInputs;
-    RedisModuleString **stringInputs;
+    RedisModuleString **keys;
+    RedisModuleString **args;
 } RAI_ScriptRunCtx;
 
 /**
@@ -46,15 +44,6 @@ int RAI_ScriptRunCtxAddInput(RAI_ScriptRunCtx *sctx, RAI_Tensor *inputTensor, RA
 int RAI_ScriptRunCtxAddInputList(RAI_ScriptRunCtx *sctx, RAI_Tensor **inputTensors, size_t len,
                                  RAI_Error *error);
 
-/**
- * @brief Adds a list length to the given script contxt.
- *
- * @param sctx input RAI_ScriptRunCtx to add the list len.
- * @param len input tensors array len
- * @return int returns 1 on success, 0 in case of error.
- */
-int RAI_ScriptRunCtxAddListSize(RAI_ScriptRunCtx *sctx, size_t len);
-
 /**
  * Allocates a RAI_ScriptCtxParam data structure, and sets the tensor reference
  * to NULL ( will be set after SCRIPTRUN ), adding it to the outputs tensors
@@ -116,24 +105,6 @@ int RAI_ScriptRun(RAI_ScriptRunCtx *sctx, RAI_Error *err);
 int RAI_ScriptRunAsync(RAI_ScriptRunCtx *sctx, RAI_OnFinishCB ScriptAsyncFinish,
                        void *private_data);
 
-/**
- * @brief Retuens the current Script Run context function signature
- *
- * @param sctx ScriptRunCtx
- * @return TorchScriptFunctionArgumentType* Null in case of no match, arr of argument type according
- * to function signature
- */
-TorchScriptFunctionArgumentType *RAI_ScriptRunCtxGetSignature(RAI_ScriptRunCtx *sctx);
-
-/**
- * @brief Returns the length of the input list in the given index.
- *
- * @param sctx ScriptRunCtx.
- * @param index Index of the list out of all the lists given as inputs.
- * @return size_t length of the input list in the given index.
- */
-size_t RAI_ScriptRunCtxGetInputListLen(RAI_ScriptRunCtx *sctx, size_t index);
-
 /**
  * Extract the ternsor parameters for the ScriptCtxRun object from AI.SCRIPTEXECUTE arguments.
  *
@@ -149,23 +120,9 @@ int ScriptRunCtx_SetParams(RedisModuleCtx *ctx, RedisModuleString **inkeys,
 
 int RAI_ScriptRunCtxAddTensorInput(RAI_ScriptRunCtx *sctx, RAI_Tensor *inputTensor);
 
-int RAI_ScriptRunCtxAddIntInput(RAI_ScriptRunCtx *sctx, int32_t i);
-
-int RAI_ScriptRunCtxAddFloatInput(RAI_ScriptRunCtx *sctx, float f);
-
-int RAI_ScriptRunCtxAddRStringInput(RAI_ScriptRunCtx *sctx, RedisModuleString *s);
-
-int RAI_ScriptRunCtxAddStringInput(RAI_ScriptRunCtx *sctx, const char *s, size_t len);
-
 int RAI_ScriptRunCtxAddTensorInputList(RAI_ScriptRunCtx *sctx, RAI_Tensor **inputTensors,
                                        size_t count);
 
-int RAI_ScriptRunCtxAddIntInputList(RAI_ScriptRunCtx *sctx, int32_t *intInputs, size_t count);
-
-int RAI_ScriptRunCtxAddFloatInputList(RAI_ScriptRunCtx *sctx, float *floatInputs, size_t count);
-
-int RAI_ScriptRunCtxAddRStringInputList(RAI_ScriptRunCtx *sctx, RedisModuleString **stringInputs,
-                                        size_t count);
+int RAI_ScriptRunCtxAddKeyInput(RAI_ScriptRunCtx *sctx, RedisModuleString *key);
 
-int RAI_ScriptRunCtxAddStringInputList(RAI_ScriptRunCtx *sctx, const char **stringInputs,
-                                       size_t *lens, size_t count);
+int RAI_ScriptRunCtxAddArgInput(RAI_ScriptRunCtx *sctx, RedisModuleString *arg);
diff --git a/src/execution/parsing/dag_parser.c b/src/execution/parsing/dag_parser.c
index 3c029eb42..b467cd463 100644
--- a/src/execution/parsing/dag_parser.c
+++ b/src/execution/parsing/dag_parser.c
@@ -245,7 +245,7 @@ int DAGInitialParsing(RedisAI_RunInfo *rinfo, RedisModuleCtx *ctx, RedisModuleSt
     bool load_complete = false;
     bool persist_complete = false;
     bool timeout_complete = false;
-    bool keys_complete = false;
+    bool routing_complete = false;
 
     // The first arg is "AI.DAGEXECUTE(_RO) (or deprecated AI.DAGRUN(_RO))", so we go over from the
     // next arg.
@@ -280,12 +280,20 @@ int DAGInitialParsing(RedisAI_RunInfo *rinfo, RedisModuleCtx *ctx, RedisModuleSt
             persist_complete = true;
             continue;
         }
-        if (!strcasecmp(arg_string, "KEYS") && !keys_complete && chainingOpCount == 0) {
-            const int parse_result = ParseKeysArgs(ctx, &argv[arg_pos], argc - arg_pos, rinfo->err);
-            if (parse_result <= 0)
+        if (!strcasecmp(arg_string, "ROUTING") && !routing_complete && chainingOpCount == 0) {
+            arg_pos++;
+            if (arg_pos == argc) {
+                RAI_SetError(rinfo->err, RAI_EDAGBUILDER, "ERR Missing ROUTING value");
                 return REDISMODULE_ERR;
-            arg_pos += parse_result;
-            keys_complete = true;
+            }
+            if (!VerifyKeyInThisShard(ctx, argv[arg_pos++])) {
+                RAI_SetError(
+                    rinfo->err, RAI_EDAGBUILDER,
+                    "ERR ROUTING value specified in the command hash to slot which does not "
+                    "belong to the current shard");
+                return REDISMODULE_ERR;
+            }
+            routing_complete = true;
             continue;
         }
         if (!strcasecmp(arg_string, "TIMEOUT") && !timeout_complete && chainingOpCount == 0) {
@@ -317,10 +325,10 @@ int DAGInitialParsing(RedisAI_RunInfo *rinfo, RedisModuleCtx *ctx, RedisModuleSt
     // commands).
     if (!strncasecmp(RedisModule_StringPtrLen(argv[0], NULL), "AI.DAGEXECUTE",
                      strlen("AI.DAGEXECUTE"))) {
-        if (!load_complete && !persist_complete && !keys_complete) {
+        if (!load_complete && !persist_complete && !routing_complete) {
             RAI_SetError(rinfo->err, RAI_EDAGBUILDER,
                          "ERR AI.DAGEXECUTE and AI.DAGEXECUTE_RO commands must "
-                         "contain at least one out of KEYS, LOAD, PERSIST keywords");
+                         "contain at least one out of ROUTING, LOAD, PERSIST keywords");
             return REDISMODULE_ERR;
         }
     }
@@ -334,9 +342,9 @@ int DAGInitialParsing(RedisAI_RunInfo *rinfo, RedisModuleCtx *ctx, RedisModuleSt
 int ParseDAGExecuteCommand(RedisAI_RunInfo *rinfo, RedisModuleCtx *ctx, RedisModuleString **argv,
                            int argc, bool dag_ro) {
 
-    // The minimal command is of the form: AI.DAGEXECUTE(_RO) KEYS/LOAD/PERSIST 1 <key> |>
+    // The minimal command is of the form: AI.DAGEXECUTE(_RO) ROUTING/LOAD/PERSIST 1 <key> |>
     // AI.TENSORGET <key>
-    if (argc < 7) {
+    if (argc < 6) {
         if (dag_ro) {
             RAI_SetError(rinfo->err, RAI_EDAGBUILDER,
                          "ERR missing arguments for 'AI.DAGEXECUTE_RO' command");
diff --git a/src/execution/parsing/deprecated.c b/src/execution/parsing/deprecated.c
index 3d95bc42c..55331bc45 100644
--- a/src/execution/parsing/deprecated.c
+++ b/src/execution/parsing/deprecated.c
@@ -342,10 +342,100 @@ int ModelSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
     return REDISMODULE_OK;
 }
 
+int ScriptSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+    if (argc != 5 && argc != 7)
+        return RedisModule_WrongArity(ctx);
+
+    ArgsCursor ac;
+    ArgsCursor_InitRString(&ac, argv + 1, argc - 1);
+
+    RedisModuleString *keystr;
+    AC_GetRString(&ac, &keystr, 0);
+
+    const char *devicestr;
+    AC_GetString(&ac, &devicestr, NULL, 0);
+
+    RedisModuleString *tag = NULL;
+    if (AC_AdvanceIfMatch(&ac, "TAG")) {
+        AC_GetRString(&ac, &tag, 0);
+    }
+
+    if (AC_IsAtEnd(&ac)) {
+        return RedisModule_ReplyWithError(ctx, "ERR Insufficient arguments, missing script SOURCE");
+    }
+
+    size_t scriptlen;
+    const char *scriptdef = NULL;
+
+    if (AC_AdvanceIfMatch(&ac, "SOURCE")) {
+        AC_GetString(&ac, &scriptdef, &scriptlen, 0);
+    }
+
+    if (scriptdef == NULL) {
+        return RedisModule_ReplyWithError(ctx, "ERR Insufficient arguments, missing script SOURCE");
+    }
+
+    RAI_Script *script = NULL;
+
+    RAI_Error err = {0};
+    script = RAI_ScriptCreate(devicestr, tag, scriptdef, &err);
+
+    if (err.code == RAI_EBACKENDNOTLOADED) {
+        RedisModule_Log(ctx, "warning",
+                        "Backend TORCH not loaded, will try loading default backend");
+        int ret = RAI_LoadDefaultBackend(ctx, RAI_BACKEND_TORCH);
+        if (ret == REDISMODULE_ERR) {
+            RedisModule_Log(ctx, "warning", "Could not load TORCH default backend");
+            int ret = RedisModule_ReplyWithError(ctx, "ERR Could not load backend");
+            RAI_ClearError(&err);
+            return ret;
+        }
+        RAI_ClearError(&err);
+        script = RAI_ScriptCreate(devicestr, tag, scriptdef, &err);
+    }
+
+    if (err.code != RAI_OK) {
+#ifdef RAI_PRINT_BACKEND_ERRORS
+        printf("ERR: %s\n", err.detail);
+#endif
+        int ret = RedisModule_ReplyWithError(ctx, err.detail_oneline);
+        RAI_ClearError(&err);
+        return ret;
+    }
+
+    if (!RunQueue_IsExists(devicestr)) {
+        RunQueueInfo *run_queue_info = RunQueue_Create(devicestr);
+        if (run_queue_info == NULL) {
+            RAI_ScriptFree(script, &err);
+            RedisModule_ReplyWithError(ctx, "ERR Could not initialize queue on requested device");
+        }
+    }
+
+    RedisModuleKey *key = RedisModule_OpenKey(ctx, keystr, REDISMODULE_READ | REDISMODULE_WRITE);
+    int type = RedisModule_KeyType(key);
+    if (type != REDISMODULE_KEYTYPE_EMPTY &&
+        !(type == REDISMODULE_KEYTYPE_MODULE &&
+          RedisModule_ModuleTypeGetType(key) == RAI_ScriptRedisType())) {
+        RedisModule_CloseKey(key);
+        return RedisModule_ReplyWithError(ctx, REDISMODULE_ERRORMSG_WRONGTYPE);
+    }
+
+    RedisModule_ModuleTypeSetValue(key, RAI_ScriptRedisType(), script);
+
+    script->infokey = RAI_AddStatsEntry(ctx, keystr, RAI_SCRIPT, RAI_BACKEND_TORCH, devicestr, tag);
+
+    RedisModule_CloseKey(key);
+
+    RedisModule_ReplyWithSimpleString(ctx, "OK");
+
+    RedisModule_ReplicateVerbatim(ctx);
+
+    return REDISMODULE_OK;
+}
+
 static int _ScriptRunCommand_ParseArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc,
                                        RAI_Error *error, RedisModuleString ***inkeys,
-                                       RedisModuleString ***outkeys, long long *timeout,
-                                       size_t **listSizes) {
+                                       RedisModuleString ***outkeys, long long *timeout) {
 
     bool is_input = false;
     bool is_output = false;
@@ -422,9 +512,6 @@ static int _ScriptRunCommand_ParseArgs(RedisModuleCtx *ctx, RedisModuleString **
             return REDISMODULE_ERR;
         }
     }
-    if (varidic_start_pos != -1) {
-        *listSizes = array_append(*listSizes, ninputs - varidic_start_pos);
-    }
 
     return REDISMODULE_OK;
 }
@@ -459,8 +546,7 @@ int ParseScriptRunCommand(RedisAI_RunInfo *rinfo, RAI_DagOp *currentOp, RedisMod
     sctx = RAI_ScriptRunCtxCreate(script, func_name);
     long long timeout = 0;
     if (_ScriptRunCommand_ParseArgs(ctx, argv, argc, rinfo->err, &currentOp->inkeys,
-                                    &currentOp->outkeys, &timeout,
-                                    &sctx->listSizes) == REDISMODULE_ERR) {
+                                    &currentOp->outkeys, &timeout) == REDISMODULE_ERR) {
         goto cleanup;
     }
     if (timeout > 0 && !rinfo->single_op_dag) {
diff --git a/src/execution/parsing/deprecated.h b/src/execution/parsing/deprecated.h
index 666ae0cb7..4adb6cf2b 100644
--- a/src/execution/parsing/deprecated.h
+++ b/src/execution/parsing/deprecated.h
@@ -18,6 +18,8 @@ int ParseScriptRunCommand(RedisAI_RunInfo *rinfo, RAI_DagOp *currentOp, RedisMod
 
 int ModelSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
 
+int ScriptSetCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
+
 /**
  * @brief Parse the arguments of the given ops in the DAGRUN command and build every op accordingly.
  * @param rinfo The DAG run info that will be populated with the ops if they are valid.
diff --git a/src/execution/parsing/parse_utils.c b/src/execution/parsing/parse_utils.c
index 45b55c40b..eac1c2a88 100644
--- a/src/execution/parsing/parse_utils.c
+++ b/src/execution/parsing/parse_utils.c
@@ -17,7 +17,7 @@ const char *ScriptCommand_GetFunctionName(RedisModuleString *functionName) {
     return functionName_cstr;
 }
 
-int ParseKeysArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, RAI_Error *err) {
+int ValidateKeysArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, RAI_Error *err) {
     if (argc < 3) {
         RAI_SetError(err, RAI_EDAGBUILDER, "ERR Missing arguments after KEYS keyword");
         return -1;
diff --git a/src/execution/parsing/parse_utils.h b/src/execution/parsing/parse_utils.h
index d4d260b19..22261c14c 100644
--- a/src/execution/parsing/parse_utils.h
+++ b/src/execution/parsing/parse_utils.h
@@ -27,4 +27,4 @@ const char *ScriptCommand_GetFunctionName(RedisModuleString *functionName);
  * @return processed number of arguments on success, or -1 if the parsing failed
  */
 
-int ParseKeysArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, RAI_Error *err);
+int ValidateKeysArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc, RAI_Error *err);
diff --git a/src/execution/parsing/script_commands_parser.c b/src/execution/parsing/script_commands_parser.c
index 7f500899e..4929fe9b3 100644
--- a/src/execution/parsing/script_commands_parser.c
+++ b/src/execution/parsing/script_commands_parser.c
@@ -4,302 +4,263 @@
 #include "util/string_utils.h"
 #include "execution/execution_contexts/scriptRun_ctx.h"
 
-static bool _Script_buildInputsBySchema(RAI_ScriptRunCtx *sctx, RedisModuleString **inputs,
-                                        RedisModuleString ***inkeys, RAI_Error *error) {
-    int signatureListCount = 0;
+static int _ScriptExecuteCommand_ParseKeys(RedisModuleCtx *ctx, RedisModuleString **argv, int argc,
+                                           size_t *argpos, RAI_Error *error,
+                                           RAI_ScriptRunCtx *sctx) {
+    size_t localArgpos = *argpos;
+    const int keys_validation_result =
+        ValidateKeysArgs(ctx, &argv[localArgpos - 1], argc - (localArgpos - 1), error);
+    if (keys_validation_result <= 0)
+        return REDISMODULE_ERR;
 
-    TorchScriptFunctionArgumentType *signature = RAI_ScriptRunCtxGetSignature(sctx);
-    if (!signature) {
+    if (localArgpos >= argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN, "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
+    }
+    long long nKeys;
+    if (RedisModule_StringToLongLong(argv[localArgpos], &nKeys) != REDISMODULE_OK) {
         RAI_SetError(error, RAI_ESCRIPTRUN,
-                     "Wrong function name given to AI.SCRIPTEXECUTE command");
-        return false;
+                     "ERR Invalid argument for keys count in AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
     }
-    size_t nlists = array_len(sctx->listSizes);
-    size_t nArguments = array_len(signature);
-    size_t nInputs = array_len(inputs);
-    size_t inputsIdx = 0;
-    size_t listIdx = 0;
+    // Check validity of keys numbers.
+    localArgpos++;
+    size_t firstKeyPos = localArgpos;
+    if (firstKeyPos + nKeys > argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN,
+                     "ERR number of keys to AI.SCRIPTEXECUTE command does not match "
+                     "the number of given arguments");
+        return REDISMODULE_ERR;
+    }
+    // Add to script run context.
+    for (; localArgpos < firstKeyPos + nKeys; localArgpos++) {
+        RAI_ScriptRunCtxAddKeyInput(sctx, RAI_HoldString(argv[localArgpos]));
+    }
+    *argpos = localArgpos;
+    return REDISMODULE_OK;
+}
 
-    if (nInputs < nArguments) {
+static int _ScriptExecuteCommand_ParseArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc,
+                                           size_t *argpos, RAI_Error *error,
+                                           RAI_ScriptRunCtx *sctx) {
+    size_t localArgpos = *argpos;
+    if (localArgpos >= argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN, "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
+    }
+    long long nArgs;
+    if (RedisModule_StringToLongLong(argv[localArgpos], &nArgs) != REDISMODULE_OK) {
         RAI_SetError(error, RAI_ESCRIPTRUN,
-                     "Wrong number of inputs provided to AI.SCRIPTEXECUTE command");
-        return false;
+                     "ERR Invalid argument for keys count in AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
     }
-    for (size_t i = 0; i < nArguments; i++) {
-        switch (signature[i]) {
-        case UNKOWN: {
-            RAI_SetError(error, RAI_ESCRIPTRUN,
-                         "Unsupported argument type in AI.SCRIPTEXECUTE command");
-            return false;
-        }
-        case TENSOR_LIST: {
-            // Collect the inputs tensor names from the current list
-            signatureListCount++;
-            if (signatureListCount > nlists) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "Wrong number of lists provided in AI.SCRIPTEXECUTE command");
-                return false;
-            }
-            size_t listLen = RAI_ScriptRunCtxGetInputListLen(sctx, listIdx++);
-            for (size_t j = 0; j < listLen; j++) {
-                *inkeys = array_append(*inkeys, RAI_HoldString(inputs[inputsIdx++]));
-            }
-            break;
-        }
-        case INT_LIST: {
-            signatureListCount++;
-            if (signatureListCount > nlists) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "Wrong number of lists provided in AI.SCRIPTEXECUTE command");
-                return false;
-            }
-            size_t listLen = RAI_ScriptRunCtxGetInputListLen(sctx, listIdx++);
-            for (size_t j = 0; j < listLen; j++) {
-                long long l;
-                RedisModule_StringToLongLong(inputs[inputsIdx++], &l);
-                RAI_ScriptRunCtxAddIntInput(sctx, (int32_t)l);
-            }
-            break;
-        }
-        case FLOAT_LIST: {
-            signatureListCount++;
-            if (signatureListCount > nlists) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "Wrong number of lists provided in AI.SCRIPTEXECUTE command");
-                return false;
-            }
-            size_t listLen = RAI_ScriptRunCtxGetInputListLen(sctx, listIdx++);
-            for (size_t j = 0; j < listLen; j++) {
-                double d;
-                RedisModule_StringToDouble(inputs[inputsIdx++], &d);
-                RAI_ScriptRunCtxAddFloatInput(sctx, (float)d);
-            }
-            break;
-        }
-        case STRING_LIST: {
-            signatureListCount++;
-            if (signatureListCount > nlists) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "Wrong number of lists provided in AI.SCRIPTEXECUTE command");
-                return false;
-            }
-            size_t listLen = RAI_ScriptRunCtxGetInputListLen(sctx, listIdx++);
-            for (size_t j = 0; j < listLen; j++) {
-                RAI_ScriptRunCtxAddRStringInput(sctx, inputs[inputsIdx++]);
-            }
-            break;
-        }
-        case INT: {
-            long long l;
-            RedisModule_StringToLongLong(inputs[inputsIdx++], &l);
-            RAI_ScriptRunCtxAddIntInput(sctx, (int32_t)l);
-            break;
-        }
-        case FLOAT: {
-            double d;
-            RedisModule_StringToDouble(inputs[inputsIdx++], &d);
-            RAI_ScriptRunCtxAddFloatInput(sctx, (float)d);
-            break;
-        }
-        case STRING: {
-            // Input is a string.
-            RAI_ScriptRunCtxAddRStringInput(sctx, inputs[inputsIdx++]);
-            break;
-        }
-        case TENSOR:
-        default: {
-            // Input is a tensor, add its name to the inkeys.
-            *inkeys = array_append(*inkeys, RAI_HoldString(inputs[inputsIdx++]));
-            break;
-        }
-        }
+    // Check validity of args numbers.
+    localArgpos++;
+    size_t firstArgPos = localArgpos;
+    if (firstArgPos + nArgs > argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN,
+                     "ERR number of args to AI.SCRIPTEXECUTE command does not match "
+                     "the number of given arguments");
+        return REDISMODULE_ERR;
+    }
+    // Add to script run context.
+    for (; localArgpos < firstArgPos + nArgs; localArgpos++) {
+        RAI_ScriptRunCtxAddArgInput(sctx, RAI_HoldString(argv[localArgpos]));
+    }
+    *argpos = localArgpos;
+    return REDISMODULE_OK;
+}
+
+static int _ScriptExecuteCommand_ParseInputs(RedisModuleCtx *ctx, RedisModuleString **argv,
+                                             int argc, size_t *argpos, RAI_Error *error,
+                                             RedisModuleString ***inputs) {
+    size_t localArgpos = *argpos;
+    if (localArgpos >= argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN, "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
+    }
+    long long nInputs;
+    if (RedisModule_StringToLongLong(argv[localArgpos], &nInputs) != REDISMODULE_OK) {
+        RAI_SetError(error, RAI_ESCRIPTRUN,
+                     "ERR Invalid argument for inputs count in AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
     }
-    if (signatureListCount != nlists) {
+    // Check validity of inputs numbers.
+    localArgpos++;
+    size_t firstInputPos = localArgpos;
+    if (firstInputPos + nInputs > argc) {
         RAI_SetError(error, RAI_ESCRIPTRUN,
-                     "Wrong number of lists provided in AI.SCRIPTEXECUTE command");
-        return false;
+                     "ERR number of inputs to AI.SCRIPTEXECUTE command does not match "
+                     "the number of given arguments");
+        return REDISMODULE_ERR;
+    }
+    // Add to inputs array.
+    for (; localArgpos < firstInputPos + nInputs; localArgpos++) {
+        *inputs = array_append(*inputs, RAI_HoldString(argv[localArgpos]));
     }
+    *argpos = localArgpos;
+    return REDISMODULE_OK;
+}
 
-    return true;
+static int _ScriptExecuteCommand_ParseOutputs(RedisModuleCtx *ctx, RedisModuleString **argv,
+                                              int argc, size_t *argpos, RAI_Error *error,
+                                              RedisModuleString ***outputs) {
+    size_t localArgpos = *argpos;
+    if (localArgpos >= argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN, "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
+    }
+    long long nOutputs;
+    if (RedisModule_StringToLongLong(argv[localArgpos], &nOutputs) != REDISMODULE_OK) {
+        RAI_SetError(error, RAI_ESCRIPTRUN,
+                     "ERR Invalid argument for outputs count in AI.SCRIPTEXECUTE");
+        return REDISMODULE_ERR;
+    }
+    // Check validity of outputs numbers.
+    localArgpos++;
+    size_t firstOutputPos = localArgpos;
+    if (firstOutputPos + nOutputs > argc) {
+        RAI_SetError(error, RAI_ESCRIPTRUN,
+                     "ERR number of outputs to AI.SCRIPTEXECUTE command does not match "
+                     "the number of given arguments");
+        return REDISMODULE_ERR;
+    }
+    // Add to outputs array.
+    for (; localArgpos < firstOutputPos + nOutputs; localArgpos++) {
+        *outputs = array_append(*outputs, RAI_HoldString(argv[localArgpos]));
+    }
+    *argpos = localArgpos;
+    return REDISMODULE_OK;
 }
 
-static int _ScriptExecuteCommand_ParseArgs(RedisModuleCtx *ctx, RedisModuleString **argv, int argc,
-                                           RAI_Error *error, RedisModuleString ***inkeys,
-                                           RedisModuleString ***outkeys, RAI_ScriptRunCtx *sctx,
-                                           long long *timeout, bool keysRequired) {
-    int argpos = 3;
+static int _ScriptExecuteCommand_ParseCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
+                                              int argc, RAI_Error *error,
+                                              RedisModuleString ***inputs,
+                                              RedisModuleString ***outputs, RAI_ScriptRunCtx *sctx,
+                                              long long *timeout, bool keysRequired) {
+    size_t argpos = 3;
     bool inputsDone = false;
     bool outputsDone = false;
-    // Local input context to verify correctness.
-    array_new_on_stack(RedisModuleString *, 10, inputs);
+    bool keysDone = false;
+    bool argsDone = false;
 
     if (keysRequired) {
         const char *arg_string = RedisModule_StringPtrLen(argv[argpos], NULL);
         if (!strcasecmp(arg_string, "KEYS")) {
-            const int parse_result = ParseKeysArgs(ctx, &argv[argpos], argc - argpos, error);
-            if (parse_result <= 0)
+            argpos++;
+            keysDone = true;
+            if (_ScriptExecuteCommand_ParseKeys(ctx, argv, argc, &argpos, error, sctx) ==
+                REDISMODULE_ERR) {
+                return REDISMODULE_ERR;
+            }
+        } else if (!strcasecmp(arg_string, "INPUTS")) {
+            argpos++;
+            inputsDone = true;
+            if (_ScriptExecuteCommand_ParseInputs(ctx, argv, argc, &argpos, error, inputs) ==
+                REDISMODULE_ERR) {
                 return REDISMODULE_ERR;
-            argpos += parse_result;
+            }
         }
-        // argv[3] is not KEYS in AI.SCRIPTEXECUTE command (i.e., not in a DAG).
+        // argv[3] is not KEYS or INPUTS in AI.SCRIPTEXECUTE command (i.e., not in a DAG).
         else {
-            RAI_SetError(error, RAI_ESCRIPTRUN,
-                         "ERR KEYS scope must be provided first for AI.SCRIPTEXECUTE command");
-            goto cleanup;
+            RAI_SetError(
+                error, RAI_ESCRIPTRUN,
+                "ERR KEYS or INPUTS scope must be provided first for AI.SCRIPTEXECUTE command");
+            return REDISMODULE_ERR;
         }
     }
 
     while (argpos < argc) {
         const char *arg_string = RedisModule_StringPtrLen(argv[argpos], NULL);
-        // See that no additional KEYS scope is provided.
-        if (!strcasecmp(arg_string, "KEYS")) {
-            RAI_SetError(error, RAI_ESCRIPTRUN,
-                         "ERR Already encountered KEYS scope in current command");
-            goto cleanup;
-        }
         // Parse timeout arg if given and store it in timeout.
         if (!strcasecmp(arg_string, "TIMEOUT")) {
             argpos++;
             if (argpos >= argc) {
                 RAI_SetError(error, RAI_ESCRIPTRUN,
                              "ERR No value provided for TIMEOUT in AI.SCRIPTEXECUTE");
-                goto cleanup;
+                return REDISMODULE_ERR;
             }
             if (ParseTimeout(argv[argpos], error, timeout) == REDISMODULE_ERR)
-                goto cleanup;
+                return REDISMODULE_ERR;
             // No other arguments expected after timeout.
             break;
         }
 
-        if (!strcasecmp(arg_string, "INPUTS")) {
-            // Check for already given inputs.
-            if (inputsDone) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Already Encountered INPUTS scope in AI.SCRIPTEXECUTE command");
-                goto cleanup;
-            }
-            inputsDone = true;
-            // Read input number.
-            argpos++;
-            if (argpos >= argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
-                goto cleanup;
-            }
-            long long ninputs;
-            if (RedisModule_StringToLongLong(argv[argpos], &ninputs) != REDISMODULE_OK) {
+        if (!strcasecmp(arg_string, "KEYS")) {
+            if (keysDone) {
                 RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid argument for input count in AI.SCRIPTEXECUTE");
-                goto cleanup;
+                             "ERR Already Encountered KEYS scope in AI.SCRIPTEXECUTE command");
+                return REDISMODULE_ERR;
             }
-            // Check validity of input numbers.
             argpos++;
-            size_t first_input_pos = argpos;
-            if (first_input_pos + ninputs > argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR number of input keys to AI.SCRIPTEXECUTE command does not match "
-                             "the number of given arguments");
-                goto cleanup;
-            }
-            // Add to local input context.
-            for (; argpos < first_input_pos + ninputs; argpos++) {
-                inputs = array_append(inputs, RAI_HoldString(argv[argpos]));
+            keysDone = true;
+            if (_ScriptExecuteCommand_ParseKeys(ctx, argv, argc, &argpos, error, sctx) ==
+                REDISMODULE_ERR) {
+                return REDISMODULE_ERR;
             }
             continue;
         }
-        if (!strcasecmp(arg_string, "OUTPUTS")) {
-            // Check for already given outputs.
-            if (outputsDone) {
+
+        if (!strcasecmp(arg_string, "ARGS")) {
+            if (argsDone) {
                 RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Already Encountered OUTPUTS scope in AI.SCRIPTEXECUTE command");
-                goto cleanup;
+                             "ERR Already Encountered ARGS scope in AI.SCRIPTEXECUTE command");
+                return REDISMODULE_ERR;
             }
-            // Update mask.
-            outputsDone = true;
-            // Read output number.
             argpos++;
-            if (argpos >= argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
-                goto cleanup;
+            argsDone = true;
+            if (_ScriptExecuteCommand_ParseArgs(ctx, argv, argc, &argpos, error, sctx) ==
+                REDISMODULE_ERR) {
+                return REDISMODULE_ERR;
             }
-            long long noutputs;
-            if (RedisModule_StringToLongLong(argv[argpos], &noutputs) != REDISMODULE_OK) {
+            continue;
+        }
+
+        if (!strcasecmp(arg_string, "INPUTS")) {
+            // Check for already given inputs.
+            if (inputsDone) {
                 RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid argument for output count in AI.SCRIPTEXECUTE");
-                goto cleanup;
+                             "ERR Already Encountered INPUTS scope in AI.SCRIPTEXECUTE command");
+                return REDISMODULE_ERR;
             }
-            // Check validity of output numbers.
             argpos++;
-            size_t first_output_pos = argpos;
-            if (first_output_pos + noutputs > argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR number of output keys to AI.SCRIPTEXECUTE command does not match "
-                             "the number of given arguments");
-                goto cleanup;
-            }
-            for (; argpos < first_output_pos + noutputs; argpos++) {
-                *outkeys = array_append(*outkeys, RAI_HoldString(argv[argpos]));
+            inputsDone = true;
+            if (_ScriptExecuteCommand_ParseInputs(ctx, argv, argc, &argpos, error, inputs) ==
+                REDISMODULE_ERR) {
+                return REDISMODULE_ERR;
             }
             continue;
         }
-        if (!strcasecmp(arg_string, "LIST_INPUTS")) {
-            // Read list size.
-            argpos++;
-            long long ninputs;
-            if (RedisModule_StringToLongLong(argv[argpos], &ninputs) != REDISMODULE_OK) {
+        if (!strcasecmp(arg_string, "OUTPUTS")) {
+            // Check for already given outputs.
+            if (outputsDone) {
                 RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid argument for list input count in AI.SCRIPTEXECUTE");
-                goto cleanup;
+                             "ERR Already Encountered OUTPUTS scope in AI.SCRIPTEXECUTE command");
+                return REDISMODULE_ERR;
             }
-            // Check validity of current list size.
             argpos++;
-            if (argpos >= argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR Invalid arguments provided to AI.SCRIPTEXECUTE");
-                goto cleanup;
-            }
-            size_t first_input_pos = argpos;
-            if (first_input_pos + ninputs > argc) {
-                RAI_SetError(error, RAI_ESCRIPTRUN,
-                             "ERR number of list input keys to AI.SCRIPTEXECUTE command does not "
-                             "match the number of given arguments");
-                goto cleanup;
-            }
-            for (; argpos < first_input_pos + ninputs; argpos++) {
-                inputs = array_append(inputs, RAI_HoldString(argv[argpos]));
+            outputsDone = true;
+            if (_ScriptExecuteCommand_ParseOutputs(ctx, argv, argc, &argpos, error, outputs) ==
+                REDISMODULE_ERR) {
+                return REDISMODULE_ERR;
             }
-            RAI_ScriptRunCtxAddListSize(sctx, ninputs);
             continue;
         }
+
         size_t error_len = strlen("ERR Invalid AI.SCRIPTEXECUTE command. Unexpected argument: ") +
                            strlen(arg_string) + 1;
         char error_str[error_len];
         sprintf(error_str, "ERR Invalid AI.SCRIPTEXECUTE command. Unexpected argument: %s",
                 arg_string);
         RAI_SetError(error, RAI_ESCRIPTRUN, error_str);
-        goto cleanup;
+        return REDISMODULE_ERR;
     }
     if (argpos != argc) {
         RAI_SetError(error, RAI_ESCRIPTRUN, "ERR Encountered problem parsing AI.SCRIPTEXECUTE");
-        goto cleanup;
-    }
-
-    if (!_Script_buildInputsBySchema(sctx, inputs, inkeys, error)) {
-        goto cleanup;
-    }
-    for (size_t i = 0; i < array_len(inputs); i++) {
-        RedisModule_FreeString(ctx, inputs[i]);
+        return REDISMODULE_ERR;
     }
-    array_free(inputs);
 
     return REDISMODULE_OK;
-cleanup:
-    for (size_t i = 0; i < array_len(inputs); i++) {
-        RedisModule_FreeString(ctx, inputs[i]);
-    }
-    array_free(inputs);
-    return REDISMODULE_ERR;
 }
 
 int ParseScriptExecuteCommand(RedisAI_RunInfo *rinfo, RAI_DagOp *currentOp,
@@ -334,9 +295,9 @@ int ParseScriptExecuteCommand(RedisAI_RunInfo *rinfo, RAI_DagOp *currentOp,
 
     sctx = RAI_ScriptRunCtxCreate(script, func_name);
     long long timeout = 0;
-    if (_ScriptExecuteCommand_ParseArgs(ctx, argv, argc, error, &currentOp->inkeys,
-                                        &currentOp->outkeys, sctx, &timeout,
-                                        rinfo->single_op_dag) == REDISMODULE_ERR) {
+    if (_ScriptExecuteCommand_ParseCommand(ctx, argv, argc, error, &currentOp->inkeys,
+                                           &currentOp->outkeys, sctx, &timeout,
+                                           rinfo->single_op_dag) == REDISMODULE_ERR) {
         goto cleanup;
     }
     if (timeout > 0 && !rinfo->single_op_dag) {
diff --git a/src/redis_ai_objects/script.c b/src/redis_ai_objects/script.c
index 5abd09dc5..57b72565b 100644
--- a/src/redis_ai_objects/script.c
+++ b/src/redis_ai_objects/script.c
@@ -20,13 +20,14 @@
 
 extern RedisModuleType *RedisAI_ScriptType;
 
-RAI_Script *RAI_ScriptCreate(const char *devicestr, RedisModuleString *tag, const char *scriptdef,
-                             RAI_Error *err) {
+RAI_Script *RAI_ScriptCompile(const char *devicestr, RedisModuleString *tag, const char *scriptdef,
+                              const char **entryPoints, size_t nEntryPoints, RAI_Error *err) {
     if (!RAI_backends.torch.script_create) {
         RAI_SetError(err, RAI_EBACKENDNOTLOADED, "ERR Backend not loaded: TORCH");
         return NULL;
     }
-    RAI_Script *script = RAI_backends.torch.script_create(devicestr, scriptdef, err);
+    RAI_Script *script =
+        RAI_backends.torch.script_create(devicestr, scriptdef, entryPoints, nEntryPoints, err);
 
     if (script) {
         if (tag) {
@@ -39,6 +40,11 @@ RAI_Script *RAI_ScriptCreate(const char *devicestr, RedisModuleString *tag, cons
     return script;
 }
 
+RAI_Script *RAI_ScriptCreate(const char *devicestr, RedisModuleString *tag, const char *scriptdef,
+                             RAI_Error *err) {
+    return RAI_ScriptCompile(devicestr, tag, scriptdef, NULL, 0, err);
+}
+
 void RAI_ScriptFree(RAI_Script *script, RAI_Error *err) {
     if (__atomic_sub_fetch(&script->refCount, 1, __ATOMIC_RELAXED) > 0) {
         return;
@@ -131,15 +137,9 @@ int RedisAI_ScriptExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
     while (argpos < argc) {
         const char *str = RedisModule_StringPtrLen(argv[argpos++], NULL);
 
-        // Inputs, outpus, keys, lists.
+        // Inputs, outpus, keys,.
         if ((!strcasecmp(str, "INPUTS")) || (!strcasecmp(str, "OUTPUTS")) ||
-            (!strcasecmp(str, "LIST_INPUTS")) || (!strcasecmp(str, "KEYS"))) {
-            bool updateKeyAtPos = false;
-            // The only scope where the inputs strings are 100% keys are in the KEYS and OUTPUTS
-            // scopes.
-            if ((!strcasecmp(str, "OUTPUTS")) || (!strcasecmp(str, "KEYS"))) {
-                updateKeyAtPos = true;
-            }
+            (!strcasecmp(str, "KEYS"))) {
             if (argpos >= argc) {
                 return REDISMODULE_ERR;
             }
@@ -153,9 +153,7 @@ int RedisAI_ScriptExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
                 return REDISMODULE_ERR;
             }
             for (long long i = 0; i < count; i++) {
-                if (updateKeyAtPos) {
-                    RedisModule_KeyAtPos(ctx, argpos);
-                }
+                RedisModule_KeyAtPos(ctx, argpos);
                 argpos++;
             }
             continue;
@@ -176,7 +174,3 @@ int RedisAI_ScriptExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
 }
 
 RedisModuleType *RAI_ScriptRedisType(void) { return RedisAI_ScriptType; }
-
-TorchScriptFunctionArgumentType *RAI_ScriptGetSignature(RAI_Script *script, const char *function) {
-    return AI_dictFetchValue(script->functionData, function);
-}
diff --git a/src/redis_ai_objects/script.h b/src/redis_ai_objects/script.h
index 72c2c0a5b..cab73ee10 100644
--- a/src/redis_ai_objects/script.h
+++ b/src/redis_ai_objects/script.h
@@ -20,13 +20,29 @@
  * @param devicestr device string
  * @param tag script model tag
  * @param scriptdef encoded script definition
- * @param error error data structure to store error message in the case of
+ * @param err error data structure to store error message in the case of
  * failures
  * @return RAI_Script script structure on success, or NULL if failed
  */
 RAI_Script *RAI_ScriptCreate(const char *devicestr, RedisModuleString *tag, const char *scriptdef,
                              RAI_Error *err);
 
+/**
+ * @brief Helper method to allocated and initialize a RAI_Script with entrypoints. Relies on Pytorch
+ * backend `script_create` callback function.
+ *
+ * @param devicestr device string
+ * @param tag script model tag
+ * @param scriptdef encoded script definition
+ * @param entryPoints array of entry point function names
+ * @param nEntryPoints number of entry points
+ * @param err error data structure to store error message in the case of
+ * failures
+ * @return RAI_Script*
+ */
+RAI_Script *RAI_ScriptCompile(const char *devicestr, RedisModuleString *tag, const char *scriptdef,
+                              const char **entryPoints, size_t nEntryPoints, RAI_Error *err);
+
 /**
  * Frees the memory of the RAI_Script when the script reference count reaches
  * 0. It is safe to call this function with a NULL input script.
@@ -101,13 +117,3 @@ int RedisAI_ScriptExecute_IsKeysPositionRequest_ReportKeys(RedisModuleCtx *ctx,
  * @return redis module type representing a script.
  */
 RedisModuleType *RAI_ScriptRedisType(void);
-
-/**
- * @brief Retuens a function signature
- *
- * @param script RAI_Script object
- * @param function function name
- * @return TorchScriptFunctionArgumentType* Null in case of no match, arr of argument type according
- * to function signature
- */
-TorchScriptFunctionArgumentType *RAI_ScriptGetSignature(RAI_Script *script, const char *function);
diff --git a/src/redis_ai_objects/script_struct.h b/src/redis_ai_objects/script_struct.h
index be6541ed1..65b3d89da 100644
--- a/src/redis_ai_objects/script_struct.h
+++ b/src/redis_ai_objects/script_struct.h
@@ -27,6 +27,5 @@ typedef struct RAI_Script {
     RedisModuleString *tag;
     long long refCount;
     void *infokey;
-    AI_dict *functionData; // A <String, TorchScriptFunctionArgumentType*> dict to map between
-                           // function name, and its schema.
+    char **entryPoints;
 } RAI_Script;
diff --git a/src/redisai.c b/src/redisai.c
index b89199754..904fa6665 100644
--- a/src/redisai.c
+++ b/src/redisai.c
@@ -671,7 +671,7 @@ int RedisAI_ScriptGet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
         return REDISMODULE_OK;
     }
 
-    int outentries = source ? 6 : 4;
+    int outentries = source ? 8 : 6;
 
     RedisModule_ReplyWithArray(ctx, outentries);
     RedisModule_ReplyWithCString(ctx, "device");
@@ -682,6 +682,12 @@ int RedisAI_ScriptGet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
         RedisModule_ReplyWithCString(ctx, "source");
         RedisModule_ReplyWithCString(ctx, sto->scriptdef);
     }
+    RedisModule_ReplyWithCString(ctx, "Entry Points");
+    size_t nEntryPoints = array_len(sto->entryPoints);
+    RedisModule_ReplyWithArray(ctx, nEntryPoints);
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        RedisModule_ReplyWithCString(ctx, sto->entryPoints[i]);
+    }
     return REDISMODULE_OK;
 }
 
@@ -712,7 +718,15 @@ int RedisAI_ScriptDel_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
  * AI.SCRIPTSET script_key device [TAG tag] SOURCE script_source
  */
 int RedisAI_ScriptSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    if (argc != 5 && argc != 7)
+    RedisModule_Log(ctx, "warning",
+                    "AI.SCRIPTSET command is deprecated and will"
+                    " not be available in future version, you can use AI.SCRIPTSTORE instead");
+    return ScriptSetCommand(ctx, argv, argc);
+}
+
+int RedisAI_ScriptStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+    // AI.SCRIPTSTORE <key> <device> ENTRY_POINTS 1 ep1 SOURCE blob
+    if (argc < 8)
         return RedisModule_WrongArity(ctx);
 
     ArgsCursor ac;
@@ -729,8 +743,25 @@ int RedisAI_ScriptSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
         AC_GetRString(&ac, &tag, 0);
     }
 
-    if (AC_IsAtEnd(&ac)) {
-        return RedisModule_ReplyWithError(ctx, "ERR Insufficient arguments, missing script SOURCE");
+    long long nEntryPoints;
+    if (AC_AdvanceIfMatch(&ac, "ENTRY_POINTS")) {
+        if (AC_GetLongLong(&ac, &nEntryPoints, 0) != AC_OK) {
+            return RedisModule_ReplyWithError(
+                ctx, "ERR Non numeric entry points number provided to AI.SCRIPTSTORE command");
+        }
+    } else {
+        return RedisModule_ReplyWithError(
+            ctx, "ERR Insufficient arguments, missing script entry points");
+    }
+
+    array_new_on_stack(const char *, nEntryPoints, entryPoints);
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        const char *entryPoint;
+        if (AC_GetString(&ac, &entryPoint, NULL, 0) != AC_OK) {
+            return RedisModule_ReplyWithError(
+                ctx, "ERR Insufficient arguments, missing script entry points");
+        }
+        entryPoints = array_append(entryPoints, entryPoint);
     }
 
     size_t scriptlen;
@@ -747,7 +778,7 @@ int RedisAI_ScriptSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
     RAI_Script *script = NULL;
 
     RAI_Error err = {0};
-    script = RAI_ScriptCreate(devicestr, tag, scriptdef, &err);
+    script = RAI_ScriptCompile(devicestr, tag, scriptdef, entryPoints, (size_t)nEntryPoints, &err);
 
     if (err.code == RAI_EBACKENDNOTLOADED) {
         RedisModule_Log(ctx, "warning",
@@ -760,13 +791,11 @@ int RedisAI_ScriptSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
             return ret;
         }
         RAI_ClearError(&err);
-        script = RAI_ScriptCreate(devicestr, tag, scriptdef, &err);
+        script =
+            RAI_ScriptCompile(devicestr, tag, scriptdef, entryPoints, (size_t)nEntryPoints, &err);
     }
 
     if (err.code != RAI_OK) {
-#ifdef RAI_PRINT_BACKEND_ERRORS
-        printf("ERR: %s\n", err.detail);
-#endif
         int ret = RedisModule_ReplyWithError(ctx, err.detail_oneline);
         RAI_ClearError(&err);
         return ret;
@@ -802,13 +831,6 @@ int RedisAI_ScriptSet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv
     return REDISMODULE_OK;
 }
 
-/*
- * Todo: this is temporary until we implement the new command, for testing broadcast in DMC
- */
-int RedisAI_ScriptStore_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    return RedisAI_ScriptSet_RedisCommand(ctx, argv, argc);
-}
-
 /**
  * AI._SCRIPTSCAN
  */
@@ -1094,16 +1116,8 @@ static int RedisAI_RegisterApi(RedisModuleCtx *ctx) {
     REGISTER_API(ScriptRunCtxCreate, ctx);
     REGISTER_API(ScriptRunCtxAddInput, ctx);
     REGISTER_API(ScriptRunCtxAddTensorInput, ctx);
-    REGISTER_API(ScriptRunCtxAddIntInput, ctx);
-    REGISTER_API(ScriptRunCtxAddFloatInput, ctx);
-    REGISTER_API(ScriptRunCtxAddRStringInput, ctx);
-    REGISTER_API(ScriptRunCtxAddStringInput, ctx);
     REGISTER_API(ScriptRunCtxAddInputList, ctx);
     REGISTER_API(ScriptRunCtxAddTensorInputList, ctx);
-    REGISTER_API(ScriptRunCtxAddIntInputList, ctx);
-    REGISTER_API(ScriptRunCtxAddFloatInputList, ctx);
-    REGISTER_API(ScriptRunCtxAddRStringInputList, ctx);
-    REGISTER_API(ScriptRunCtxAddStringInputList, ctx);
     REGISTER_API(ScriptRunCtxAddOutput, ctx);
     REGISTER_API(ScriptRunCtxNumOutputs, ctx);
     REGISTER_API(ScriptRunCtxOutputTensor, ctx);
diff --git a/src/redisai.h b/src/redisai.h
index e63b17297..9804263eb 100644
--- a/src/redisai.h
+++ b/src/redisai.h
@@ -153,35 +153,10 @@ REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddInputList)(RAI_ScriptRunC
 REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddTensorInput)(RAI_ScriptRunCtx *sctx,
                                                                     RAI_Tensor *inputTensor);
 
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddIntInput)(RAI_ScriptRunCtx *sctx, int32_t i);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddFloatInput)(RAI_ScriptRunCtx *sctx, float f);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddRStringInput)(RAI_ScriptRunCtx *sctx,
-                                                                     RedisModuleString *s);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddStringInput)(RAI_ScriptRunCtx *sctx,
-                                                                    const char *s, size_t len);
-
 REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddTensorInputList)(RAI_ScriptRunCtx *sctx,
                                                                         RAI_Tensor **inputTensors,
                                                                         size_t count);
 
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddIntInputList)(RAI_ScriptRunCtx *sctx,
-                                                                     int32_t *intInputs,
-                                                                     size_t count);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddFloatInputList)(RAI_ScriptRunCtx *sctx,
-                                                                       float *floatInputs,
-                                                                       size_t count);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddRStringInputList)(
-    RAI_ScriptRunCtx *sctx, RedisModuleString **stringInputs, size_t count);
-
-REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddStringInputList)(RAI_ScriptRunCtx *sctx,
-                                                                        const char **stringInputs,
-                                                                        size_t *lens, size_t count);
-
 REDISAI_API int MODULE_API_FUNC(RedisAI_ScriptRunCtxAddOutput)(RAI_ScriptRunCtx *sctx);
 REDISAI_API size_t MODULE_API_FUNC(RedisAI_ScriptRunCtxNumOutputs)(RAI_ScriptRunCtx *sctx);
 REDISAI_API RAI_Tensor *MODULE_API_FUNC(RedisAI_ScriptRunCtxOutputTensor)(RAI_ScriptRunCtx *sctx,
@@ -302,16 +277,8 @@ static int RedisAI_Initialize(RedisModuleCtx *ctx) {
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxCreate);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddInput);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddTensorInput);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddIntInput);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddFloatInput);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddRStringInput);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddStringInput);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddInputList);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddTensorInputList);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddIntInputList);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddFloatInputList);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddRStringInputList);
-    REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddStringInputList);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxAddOutput);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxNumOutputs);
     REDISAI_MODULE_INIT_FUNCTION(ctx, ScriptRunCtxOutputTensor);
diff --git a/src/serialization/AOF/rai_aof_rewrite.c b/src/serialization/AOF/rai_aof_rewrite.c
index 29d8dd6e3..6a81f3830 100644
--- a/src/serialization/AOF/rai_aof_rewrite.c
+++ b/src/serialization/AOF/rai_aof_rewrite.c
@@ -110,6 +110,30 @@ void RAI_AOFRewriteModel(RedisModuleIO *aof, RedisModuleString *key, void *value
 
 void RAI_AOFRewriteScript(RedisModuleIO *aof, RedisModuleString *key, void *value) {
     RAI_Script *script = (RAI_Script *)value;
-    RedisModule_EmitAOF(aof, "AI.SCRIPTSET", "sccscc", key, script->devicestr, "TAG", script->tag,
-                        "SOURCE", script->scriptdef);
+    RedisModuleString **args = array_new(RedisModuleString *, 9);
+    args = array_append(args, RedisModule_CreateStringFromString(NULL, key));
+    args = array_append(
+        args, RedisModule_CreateString(NULL, script->devicestr, strlen(script->devicestr)));
+    args = array_append(args, RedisModule_CreateString(NULL, "TAG", strlen("TAG")));
+    args = array_append(args, RedisModule_CreateStringFromString(NULL, script->tag));
+    size_t nEntryPoints = array_len(script->entryPoints);
+    if (nEntryPoints > 0) {
+        args = array_append(args,
+                            RedisModule_CreateString(NULL, "ENTRY_POINTS", strlen("ENTRY_POINTS")));
+        args =
+            array_append(args, RedisModule_CreateStringFromLongLong(NULL, (long long)nEntryPoints));
+        for (size_t i = 0; i < nEntryPoints; i++) {
+            args = array_append(args, RedisModule_CreateString(NULL, script->entryPoints[i],
+                                                               strlen(script->entryPoints[i])));
+        }
+    }
+    args = array_append(args, RedisModule_CreateString(NULL, "SOURCE", strlen("SOURCE")));
+    args = array_append(
+        args, RedisModule_CreateString(NULL, script->scriptdef, strlen(script->scriptdef)));
+
+    RedisModule_EmitAOF(aof, "AI.SCRIPTSTORE", "v", args, array_len(args));
+    for (size_t i = 0; i < array_len(args); i++) {
+        RedisModule_FreeString(NULL, args[i]);
+    }
+    array_free(args);
 }
diff --git a/src/serialization/RDB/decoder/current/v3/decode_v3.c b/src/serialization/RDB/decoder/current/v3/decode_v3.c
new file mode 100644
index 000000000..6c5de9f81
--- /dev/null
+++ b/src/serialization/RDB/decoder/current/v3/decode_v3.c
@@ -0,0 +1,287 @@
+#include "decode_v3.h"
+#include "assert.h"
+
+/**
+ * In case of IO errors, the default return values are:
+ * numbers - 0
+ * strings - null
+ * So only when it is necessary check for IO errors.
+ */
+
+void *RAI_RDBLoadTensor_v3(RedisModuleIO *io) {
+    int64_t *shape = NULL;
+    int64_t *strides = NULL;
+
+    DLDevice device;
+    device.device_type = RedisModule_LoadUnsigned(io);
+    device.device_id = RedisModule_LoadUnsigned(io);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    // For now we only support CPU tensors (except during model and script run)
+    assert(device.device_type == kDLCPU);
+    if (device.device_id != -1) {
+        device.device_id = -1;
+    }
+
+    DLDataType dtype;
+    dtype.bits = RedisModule_LoadUnsigned(io);
+    dtype.code = RedisModule_LoadUnsigned(io);
+    dtype.lanes = RedisModule_LoadUnsigned(io);
+
+    size_t ndims = RedisModule_LoadUnsigned(io);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    shape = RedisModule_Calloc(ndims, sizeof(*shape));
+    for (size_t i = 0; i < ndims; ++i) {
+        shape[i] = RedisModule_LoadUnsigned(io);
+    }
+
+    strides = RedisModule_Calloc(ndims, sizeof(*strides));
+    for (size_t i = 0; i < ndims; ++i) {
+        strides[i] = RedisModule_LoadUnsigned(io);
+    }
+
+    size_t byte_offset = RedisModule_LoadUnsigned(io);
+
+    size_t len;
+    char *data = RedisModule_LoadStringBuffer(io, &len);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    RAI_Tensor *ret = RAI_TensorNew();
+    ret->tensor = (DLManagedTensor){.dl_tensor = (DLTensor){.device = device,
+                                                            .data = data,
+                                                            .ndim = ndims,
+                                                            .dtype = dtype,
+                                                            .shape = shape,
+                                                            .strides = strides,
+                                                            .byte_offset = byte_offset},
+                                    .manager_ctx = NULL,
+                                    .deleter = NULL};
+    return ret;
+
+cleanup:
+    if (shape)
+        RedisModule_Free(shape);
+    if (strides)
+        RedisModule_Free(strides);
+    RedisModule_LogIOError(io, "error", "Experienced a short read while reading a tensor from RDB");
+    return NULL;
+}
+
+void *RAI_RDBLoadModel_v3(RedisModuleIO *io) {
+
+    char *devicestr = NULL;
+    RedisModuleString *tag = NULL;
+    size_t ninputs = 0;
+    const char **inputs = NULL;
+    size_t noutputs = 0;
+    const char **outputs = NULL;
+    char *buffer = NULL;
+
+    RAI_Backend backend = RedisModule_LoadUnsigned(io);
+    devicestr = RedisModule_LoadStringBuffer(io, NULL);
+    tag = RedisModule_LoadString(io);
+
+    const size_t batchsize = RedisModule_LoadUnsigned(io);
+    const size_t minbatchsize = RedisModule_LoadUnsigned(io);
+    const size_t minbatchtimeout = RedisModule_LoadUnsigned(io);
+
+    ninputs = RedisModule_LoadUnsigned(io);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    inputs = RedisModule_Alloc(ninputs * sizeof(char *));
+
+    for (size_t i = 0; i < ninputs; i++) {
+        inputs[i] = RedisModule_LoadStringBuffer(io, NULL);
+    }
+
+    noutputs = RedisModule_LoadUnsigned(io);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    outputs = RedisModule_Alloc(noutputs * sizeof(char *));
+
+    for (size_t i = 0; i < noutputs; i++) {
+        outputs[i] = RedisModule_LoadStringBuffer(io, NULL);
+    }
+
+    RAI_ModelOpts opts = {
+        .batchsize = batchsize,
+        .minbatchsize = minbatchsize,
+        .minbatchtimeout = minbatchtimeout,
+        .backends_intra_op_parallelism = Config_GetBackendsIntraOpParallelism(),
+        .backends_inter_op_parallelism = Config_GetBackendsInterOpParallelism(),
+    };
+
+    size_t len = RedisModule_LoadUnsigned(io);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    buffer = RedisModule_Alloc(len);
+    const size_t n_chunks = RedisModule_LoadUnsigned(io);
+    long long chunk_offset = 0;
+    for (size_t i = 0; i < n_chunks; i++) {
+        size_t chunk_len;
+        char *chunk_buffer = RedisModule_LoadStringBuffer(io, &chunk_len);
+        if (RedisModule_IsIOError(io))
+            goto cleanup;
+        memcpy(buffer + chunk_offset, chunk_buffer, chunk_len);
+        chunk_offset += chunk_len;
+        RedisModule_Free(chunk_buffer);
+    }
+
+    RAI_Error err = {0};
+    RAI_Model *model = RAI_ModelCreate(backend, devicestr, tag, opts, ninputs, inputs, noutputs,
+                                       outputs, buffer, len, &err);
+
+    if (err.code == RAI_EBACKENDNOTLOADED) {
+        RedisModuleCtx *ctx = RedisModule_GetContextFromIO(io);
+        int ret = RAI_LoadDefaultBackend(ctx, backend);
+        if (ret == REDISMODULE_ERR) {
+            RedisModule_Log(ctx, "warning", "Could not load default backend");
+            RAI_ClearError(&err);
+            goto cleanup;
+        }
+        RAI_ClearError(&err);
+        model = RAI_ModelCreate(backend, devicestr, tag, opts, ninputs, inputs, noutputs, outputs,
+                                buffer, len, &err);
+    }
+
+    if (err.code != RAI_OK) {
+        RedisModuleCtx *ctx = RedisModule_GetContextFromIO(io);
+        RedisModule_Log(ctx, "warning", "%s", err.detail);
+        RAI_ClearError(&err);
+        goto cleanup;
+    }
+
+    RedisModuleCtx *stats_ctx = RedisModule_GetContextFromIO(io);
+    RedisModuleString *stats_keystr =
+        RedisModule_CreateStringFromString(stats_ctx, RedisModule_GetKeyNameFromIO(io));
+
+    model->infokey = RAI_AddStatsEntry(stats_ctx, stats_keystr, RAI_MODEL, backend, devicestr, tag);
+
+    for (size_t i = 0; i < ninputs; i++) {
+        RedisModule_Free((void *)inputs[i]);
+    }
+    RedisModule_Free(inputs);
+    for (size_t i = 0; i < noutputs; i++) {
+        RedisModule_Free((void *)outputs[i]);
+    }
+    RedisModule_Free(outputs);
+    RedisModule_Free(buffer);
+    RedisModule_Free(devicestr);
+    RedisModule_FreeString(NULL, stats_keystr);
+    RedisModule_FreeString(NULL, tag);
+
+    return model;
+
+cleanup:
+    if (devicestr)
+        RedisModule_Free(devicestr);
+    if (tag)
+        RedisModule_FreeString(NULL, tag);
+    if (inputs) {
+        for (size_t i = 0; i < ninputs; i++) {
+            RedisModule_Free((void *)inputs[i]);
+        }
+        RedisModule_Free(inputs);
+    }
+
+    if (outputs) {
+        for (size_t i = 0; i < noutputs; i++) {
+            RedisModule_Free((void *)outputs[i]);
+        }
+        RedisModule_Free(outputs);
+    }
+
+    if (buffer)
+        RedisModule_Free(buffer);
+
+    RedisModule_LogIOError(io, "error", "Experienced a short read while reading a model from RDB");
+    return NULL;
+}
+
+void *RAI_RDBLoadScript_v3(RedisModuleIO *io) {
+    RedisModuleString *tag = NULL;
+    char *devicestr = NULL;
+    char *scriptdef = NULL;
+    size_t nEntryPoints = 0;
+    char **entryPoints = NULL;
+    RAI_Error err = {0};
+
+    size_t len;
+    devicestr = RedisModule_LoadStringBuffer(io, &len);
+    tag = RedisModule_LoadString(io);
+
+    scriptdef = RedisModule_LoadStringBuffer(io, &len);
+    if (RedisModule_IsIOError(io))
+        goto cleanup;
+
+    nEntryPoints = (size_t)RedisModule_LoadUnsigned(io);
+    entryPoints = array_new(char *, nEntryPoints);
+
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        char *entryPoint = RedisModule_LoadStringBuffer(io, &len);
+        if (RedisModule_IsIOError(io)) {
+            goto cleanup;
+        }
+        entryPoints = array_append(entryPoints, entryPoint);
+    }
+
+    RAI_Script *script = RAI_ScriptCompile(devicestr, tag, scriptdef, (const char **)entryPoints,
+                                           nEntryPoints, &err);
+
+    if (err.code == RAI_EBACKENDNOTLOADED) {
+        RedisModuleCtx *ctx = RedisModule_GetContextFromIO(io);
+        int ret = RAI_LoadDefaultBackend(ctx, RAI_BACKEND_TORCH);
+        if (ret == REDISMODULE_ERR) {
+            RedisModule_Log(ctx, "warning", "Could not load default TORCH backend\n");
+            RAI_ClearError(&err);
+            goto cleanup;
+        }
+        RAI_ClearError(&err);
+        script = RAI_ScriptCompile(devicestr, tag, scriptdef, (const char **)entryPoints,
+                                   nEntryPoints, &err);
+    }
+
+    if (err.code != RAI_OK) {
+        printf("ERR: %s\n", err.detail);
+        RAI_ClearError(&err);
+        goto cleanup;
+    }
+
+    RedisModuleCtx *stats_ctx = RedisModule_GetContextFromIO(io);
+    RedisModuleString *stats_keystr =
+        RedisModule_CreateStringFromString(stats_ctx, RedisModule_GetKeyNameFromIO(io));
+
+    script->infokey =
+        RAI_AddStatsEntry(stats_ctx, stats_keystr, RAI_SCRIPT, RAI_BACKEND_TORCH, devicestr, tag);
+
+    RedisModule_FreeString(NULL, stats_keystr);
+    RedisModule_FreeString(NULL, tag);
+    RedisModule_Free(devicestr);
+    RedisModule_Free(scriptdef);
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        RedisModule_Free(entryPoints[i]);
+    }
+    array_free(entryPoints);
+    return script;
+cleanup:
+    if (devicestr)
+        RedisModule_Free(devicestr);
+    if (scriptdef)
+        RedisModule_Free(scriptdef);
+    if (tag)
+        RedisModule_FreeString(NULL, tag);
+    if (entryPoints) {
+        for (size_t i = 0; i < nEntryPoints; i++) {
+            RedisModule_Free(entryPoints[i]);
+        }
+        array_free(entryPoints);
+    }
+    return NULL;
+}
diff --git a/src/serialization/RDB/decoder/current/v3/decode_v3.h b/src/serialization/RDB/decoder/current/v3/decode_v3.h
new file mode 100644
index 000000000..12bc4e924
--- /dev/null
+++ b/src/serialization/RDB/decoder/current/v3/decode_v3.h
@@ -0,0 +1,8 @@
+#pragma once
+#include "serialization/serialization_include.h"
+
+void *RAI_RDBLoadTensor_v3(RedisModuleIO *io);
+
+void *RAI_RDBLoadModel_v3(RedisModuleIO *io);
+
+void *RAI_RDBLoadScript_v3(RedisModuleIO *io);
diff --git a/src/serialization/RDB/decoder/decode_previous.c b/src/serialization/RDB/decoder/decode_previous.c
index 410b3b328..69773bff6 100644
--- a/src/serialization/RDB/decoder/decode_previous.c
+++ b/src/serialization/RDB/decoder/decode_previous.c
@@ -1,6 +1,7 @@
 #include "decode_previous.h"
 #include "previous/v0/decode_v0.h"
 #include "previous/v1/decode_v1.h"
+#include "previous/v2/decode_v2.h"
 
 void *Decode_PreviousTensor(RedisModuleIO *rdb, int encver) {
     switch (encver) {
@@ -8,6 +9,8 @@ void *Decode_PreviousTensor(RedisModuleIO *rdb, int encver) {
         return RAI_RDBLoadTensor_v0(rdb);
     case 1:
         return RAI_RDBLoadTensor_v1(rdb);
+    case 2:
+        return RAI_RDBLoadTensor_v2(rdb);
     default:
         assert(false && "Invalid encoding version");
     }
@@ -20,6 +23,8 @@ void *Decode_PreviousModel(RedisModuleIO *rdb, int encver) {
         return RAI_RDBLoadModel_v0(rdb);
     case 1:
         return RAI_RDBLoadModel_v1(rdb);
+    case 2:
+        return RAI_RDBLoadModel_v2(rdb);
     default:
         assert(false && "Invalid encoding version");
     }
@@ -32,6 +37,8 @@ void *Decode_PreviousScript(RedisModuleIO *rdb, int encver) {
         return RAI_RDBLoadScript_v0(rdb);
     case 1:
         return RAI_RDBLoadScript_v1(rdb);
+    case 2:
+        return RAI_RDBLoadScript_v2(rdb);
     default:
         assert(false && "Invalid encoding version");
     }
diff --git a/src/serialization/RDB/decoder/current/v2/decode_v2.c b/src/serialization/RDB/decoder/previous/v2/decode_v2.c
similarity index 100%
rename from src/serialization/RDB/decoder/current/v2/decode_v2.c
rename to src/serialization/RDB/decoder/previous/v2/decode_v2.c
diff --git a/src/serialization/RDB/decoder/current/v2/decode_v2.h b/src/serialization/RDB/decoder/previous/v2/decode_v2.h
similarity index 100%
rename from src/serialization/RDB/decoder/current/v2/decode_v2.h
rename to src/serialization/RDB/decoder/previous/v2/decode_v2.h
diff --git a/src/serialization/RDB/decoder/rai_rdb_decoder.c b/src/serialization/RDB/decoder/rai_rdb_decoder.c
index 19b179c48..344d8a88d 100644
--- a/src/serialization/RDB/decoder/rai_rdb_decoder.c
+++ b/src/serialization/RDB/decoder/rai_rdb_decoder.c
@@ -1,8 +1,8 @@
 #include "rai_rdb_decoder.h"
-#include "current/v2/decode_v2.h"
+#include "current/v3/decode_v3.h"
 
-void *RAI_RDBLoadTensor(RedisModuleIO *io) { return RAI_RDBLoadTensor_v2(io); }
+void *RAI_RDBLoadTensor(RedisModuleIO *io) { return RAI_RDBLoadTensor_v3(io); }
 
-void *RAI_RDBLoadModel(RedisModuleIO *io) { return RAI_RDBLoadModel_v2(io); }
+void *RAI_RDBLoadModel(RedisModuleIO *io) { return RAI_RDBLoadModel_v3(io); }
 
-void *RAI_RDBLoadScript(RedisModuleIO *io) { return RAI_RDBLoadScript_v2(io); }
+void *RAI_RDBLoadScript(RedisModuleIO *io) { return RAI_RDBLoadScript_v3(io); }
diff --git a/src/serialization/RDB/encoder/rai_rdb_encode.c b/src/serialization/RDB/encoder/rai_rdb_encode.c
index 744cec9f1..4a018f53a 100644
--- a/src/serialization/RDB/encoder/rai_rdb_encode.c
+++ b/src/serialization/RDB/encoder/rai_rdb_encode.c
@@ -1,8 +1,8 @@
 #include "rai_rdb_encode.h"
-#include "v2/encode_v2.h"
+#include "v3/encode_v3.h"
 
-void RAI_RDBSaveTensor(RedisModuleIO *io, void *value) { RAI_RDBSaveTensor_v2(io, value); }
+void RAI_RDBSaveTensor(RedisModuleIO *io, void *value) { RAI_RDBSaveTensor_v3(io, value); }
 
-void RAI_RDBSaveModel(RedisModuleIO *io, void *value) { RAI_RDBSaveModel_v2(io, value); }
+void RAI_RDBSaveModel(RedisModuleIO *io, void *value) { RAI_RDBSaveModel_v3(io, value); }
 
-void RAI_RDBSaveScript(RedisModuleIO *io, void *value) { RAI_RDBSaveScript_v2(io, value); }
+void RAI_RDBSaveScript(RedisModuleIO *io, void *value) { RAI_RDBSaveScript_v3(io, value); }
diff --git a/src/serialization/RDB/encoder/v2/encode_v2.h b/src/serialization/RDB/encoder/v2/encode_v2.h
deleted file mode 100644
index 2f1e485c6..000000000
--- a/src/serialization/RDB/encoder/v2/encode_v2.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-#include "../../../serialization_include.h"
-
-void RAI_RDBSaveTensor_v2(RedisModuleIO *io, void *value);
-
-void RAI_RDBSaveModel_v2(RedisModuleIO *io, void *value);
-
-void RAI_RDBSaveScript_v2(RedisModuleIO *io, void *value);
diff --git a/src/serialization/RDB/encoder/v2/encode_v2.c b/src/serialization/RDB/encoder/v3/encode_v3.c
similarity index 82%
rename from src/serialization/RDB/encoder/v2/encode_v2.c
rename to src/serialization/RDB/encoder/v3/encode_v3.c
index f2e34ca2a..343134033 100644
--- a/src/serialization/RDB/encoder/v2/encode_v2.c
+++ b/src/serialization/RDB/encoder/v3/encode_v3.c
@@ -1,6 +1,6 @@
-#include "encode_v2.h"
+#include "encode_v3.h"
 
-void RAI_RDBSaveTensor_v2(RedisModuleIO *io, void *value) {
+void RAI_RDBSaveTensor_v3(RedisModuleIO *io, void *value) {
     RAI_Tensor *tensor = (RAI_Tensor *)value;
 
     size_t ndim = tensor->tensor.dl_tensor.ndim;
@@ -23,7 +23,7 @@ void RAI_RDBSaveTensor_v2(RedisModuleIO *io, void *value) {
     RedisModule_SaveStringBuffer(io, tensor->tensor.dl_tensor.data, size);
 }
 
-void RAI_RDBSaveModel_v2(RedisModuleIO *io, void *value) {
+void RAI_RDBSaveModel_v3(RedisModuleIO *io, void *value) {
     RAI_Model *model = (RAI_Model *)value;
     char *buffer = NULL;
     size_t len = 0;
@@ -69,12 +69,17 @@ void RAI_RDBSaveModel_v2(RedisModuleIO *io, void *value) {
     }
 }
 
-void RAI_RDBSaveScript_v2(RedisModuleIO *io, void *value) {
+void RAI_RDBSaveScript_v3(RedisModuleIO *io, void *value) {
     RAI_Script *script = (RAI_Script *)value;
 
-    size_t len = strlen(script->scriptdef) + 1;
-
     RedisModule_SaveStringBuffer(io, script->devicestr, strlen(script->devicestr) + 1);
     RedisModule_SaveString(io, script->tag);
-    RedisModule_SaveStringBuffer(io, script->scriptdef, len);
+    RedisModule_SaveStringBuffer(io, script->scriptdef, strlen(script->scriptdef) + 1);
+    size_t nEntryPoints = array_len(script->entryPoints);
+
+    RedisModule_SaveUnsigned(io, nEntryPoints);
+    for (size_t i = 0; i < nEntryPoints; i++) {
+        RedisModule_SaveStringBuffer(io, script->entryPoints[i],
+                                     strlen(script->entryPoints[i]) + 1);
+    }
 }
diff --git a/src/serialization/RDB/encoder/v3/encode_v3.h b/src/serialization/RDB/encoder/v3/encode_v3.h
new file mode 100644
index 000000000..4d7939d33
--- /dev/null
+++ b/src/serialization/RDB/encoder/v3/encode_v3.h
@@ -0,0 +1,8 @@
+#pragma once
+#include "../../../serialization_include.h"
+
+void RAI_RDBSaveTensor_v3(RedisModuleIO *io, void *value);
+
+void RAI_RDBSaveModel_v3(RedisModuleIO *io, void *value);
+
+void RAI_RDBSaveScript_v3(RedisModuleIO *io, void *value);
diff --git a/src/version.h b/src/version.h
index 6e79efb96..ac57685e3 100644
--- a/src/version.h
+++ b/src/version.h
@@ -10,4 +10,4 @@
 /* API versions. */
 #define REDISAI_LLAPI_VERSION 1
 
-static const long long REDISAI_ENC_VER = 2;
+static const long long REDISAI_ENC_VER = 3;
diff --git a/tests/flow/includes.py b/tests/flow/includes.py
index d42ff402a..80ab233f4 100755
--- a/tests/flow/includes.py
+++ b/tests/flow/includes.py
@@ -95,6 +95,30 @@ def load_resnet_test_data():
 
     return model_pb, script, labels, img
 
+def load_resnet_test_data_old():
+    test_data_path = os.path.join(os.path.dirname(__file__), 'test_data/imagenet')
+    labels_filename = os.path.join(test_data_path, 'imagenet_class_index.json')
+    image_filename = os.path.join(test_data_path, 'dog.jpg')
+    model_filename = os.path.join(test_data_path, 'resnet50.pb')
+    script_filename = os.path.join(test_data_path, 'data_processing_script_old.txt')
+
+    with open(script_filename, 'rb') as f:
+        script = f.read()
+
+    with open(model_filename, 'rb') as f:
+        model_pb = f.read()
+
+    with open(labels_filename, 'r') as f:
+        labels = json.load(f)
+
+    img_height, img_width = 224, 224
+
+    img = imread(image_filename)
+    img = resize(img, (img_height, img_width), mode='constant', anti_aliasing=True)
+    img = img.astype(np.uint8)
+
+    return model_pb, script, labels, img
+
 
 def load_mobilenet_v1_test_data():
     test_data_path = os.path.join(os.path.dirname(__file__), 'test_data')
diff --git a/tests/flow/test_data/imagenet/data_processing_script.txt b/tests/flow/test_data/imagenet/data_processing_script.txt
index d7610799e..c5f1a5f65 100644
--- a/tests/flow/test_data/imagenet/data_processing_script.txt
+++ b/tests/flow/test_data/imagenet/data_processing_script.txt
@@ -1,12 +1,17 @@
-def pre_process_3ch(image):
+def pre_process_3ch(tensors: List[Tensor], keys: List[str], args: List[str]):
+    image = tensors[0]
     return image.float().div(255).unsqueeze(0)
 
-def pre_process_4ch(image):
+def pre_process_4ch(tensors: List[Tensor], keys: List[str], args: List[str]):
+    image = tensors[0]
     return image.float().div(255)[:,:,:-1].contiguous().unsqueeze(0)
 
-def post_process(output):
+def post_process(tensors: List[Tensor], keys: List[str], args: List[str]):
+    output = tensors[0]
     # tf model has 1001 classes, hence negative 1
     return output.max(1)[1] - 1
 
-def ensemble(output0, output1):
+def ensemble(tensors: List[Tensor], keys: List[str], args: List[str]):
+    output0 = tensors[0]
+    output1 = tensors[1]
     return (output0 + output1) * 0.5
diff --git a/tests/flow/test_data/imagenet/data_processing_script_old.txt b/tests/flow/test_data/imagenet/data_processing_script_old.txt
new file mode 100644
index 000000000..d7610799e
--- /dev/null
+++ b/tests/flow/test_data/imagenet/data_processing_script_old.txt
@@ -0,0 +1,12 @@
+def pre_process_3ch(image):
+    return image.float().div(255).unsqueeze(0)
+
+def pre_process_4ch(image):
+    return image.float().div(255)[:,:,:-1].contiguous().unsqueeze(0)
+
+def post_process(output):
+    # tf model has 1001 classes, hence negative 1
+    return output.max(1)[1] - 1
+
+def ensemble(output0, output1):
+    return (output0 + output1) * 0.5
diff --git a/tests/flow/test_data/old_script.txt b/tests/flow/test_data/old_script.txt
new file mode 100644
index 000000000..34e4b9317
--- /dev/null
+++ b/tests/flow/test_data/old_script.txt
@@ -0,0 +1,5 @@
+def bar(a, b):
+    return a + b
+
+def bar_variadic(a, args : List[Tensor]):
+    return args[0] + args[1]
diff --git a/tests/flow/test_data/rdb_test_prep_script.py b/tests/flow/test_data/rdb_test_prep_script.py
new file mode 100644
index 000000000..c4d9d4190
--- /dev/null
+++ b/tests/flow/test_data/rdb_test_prep_script.py
@@ -0,0 +1,61 @@
+# When update of RDB encoding version is needed, use this script to load models and scripts to RedisAI with the new 
+# RDB encoding, dump the content as RDB strings and add those to a the new encoding test on test_serializations.py
+import redis
+
+RDB_Version = "V3"
+
+
+def load_file_content(filename):
+    with open(filename, 'rb') as f:
+        return f.read()
+
+
+def main():
+    con = redis.Redis()
+
+    # TENSOR
+    con.execute_command('AI.TENSORSET', 'tensor{1}', 'INT32', 2, 1, 'VALUES', 1, 2)
+
+    # TF
+    model_pb = load_file_content('graph.pb')
+    con.execute_command('AI.MODELSTORE', 'tf_graph{1}', 'TF', 'CPU', 
+                        'TAG', f'TF_GRAPH_{RDB_Version}', 'BATCHSIZE', 4, 'MINBATCHSIZE', 2, 'MINBATCHTIMEOUT', 1000,
+                        'INPUTS', 2, 'a', 'b', 'OUTPUTS', 1, 'mul', 'BLOB', model_pb)
+
+    # TORCH
+    model_pb = load_file_content('pt-minimal.pt')
+    con.execute_command('AI.MODELSTORE', 'pt_minimal{1}', 'TORCH', 'CPU', 
+                        'TAG', f'PT_MINIMAL_{RDB_Version}', 'BATCHSIZE', 4, 'MINBATCHSIZE', 2, 'MINBATCHTIMEOUT', 1000,
+                        'BLOB', model_pb)
+
+    # ONNX
+    model_pb = load_file_content('linear_iris.onnx')
+    con.execute_command('AI.MODELSTORE', 'linear_iris{1}', 'ONNX', 'CPU', 
+                        'TAG', f'ONNX_LINEAR_IRIS_{RDB_Version}', 'BATCHSIZE', 4, 'MINBATCHSIZE', 2, 'MINBATCHTIMEOUT', 1000,
+                        'BLOB', model_pb)
+
+    # TORCH SCRIPT
+    script = load_file_content('script.txt')
+    con.execute_command('AI.SCRIPTSTORE', 'torch_script{1}', 'CPU', 
+                        'TAG', f'TORCH_SCRIPT_{RDB_Version}', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic',
+                        'SOURCE', script)
+
+    print('tensor dump')
+    print(con.dump('tensor{1}'))
+
+    print('tf dump')
+    print(con.dump('tf_graph{1}'))
+
+    print('torch dump')
+    print(con.dump('pt_minimal{1}'))
+
+    print('onnx dump')
+    print(con.dump('linear_iris{1}'))
+
+    print('script dump')
+    print(con.dump('torch_script{1}'))
+
+if __name__== "__main__":
+    main()
+
+
diff --git a/tests/flow/test_data/redis_scripts.py b/tests/flow/test_data/redis_scripts.py
index 856b0aba6..7eb4b9a0d 100644
--- a/tests/flow/test_data/redis_scripts.py
+++ b/tests/flow/test_data/redis_scripts.py
@@ -22,73 +22,91 @@ def redis_hash_to_tensor(redis_value: Any):
     l  = [torch.tensor(int(str(v))).reshape(1,1) for v in values]
     return torch.cat(l, dim=0)
 
-def test_redis_command_error(key:str):
+def test_redis_error(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    redis.execute("SET", key)
+
+def test_redis_command_error(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
     redis.execute("SET", key)  # missing the required value argument
 
-def test_redis_error_message(key:str):
+def test_redis_error_message(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
     redis.execute("HSET", key, "field", "value")
     redis.execute("RPUSH", key, "some_value")  # list command on a hash type
 
-def test_int_set_get(key:str, value:int):
-    redis.execute("SET", key, str(value))
+def test_int_set_get(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    value = args[0]
+    redis.execute("SET", key, value)
     res = redis.execute("GET", key)
     redis.execute("DEL", key)
     return redis_string_int_to_tensor(res)
 
-def test_int_set_incr(key:str, value:int):
-    redis.execute("SET", key, str(value))
+def test_int_set_incr(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    value = args[0]
+    redis.execute("SET", key, value)
     res = redis.execute("INCR", key)
     redis.execute("DEL", key)
     return redis_string_int_to_tensor(res)
 
-def test_float_set_get(key:str, value:float):
-    redis.execute("SET", key, str(value))
+def test_float_set_get(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    value = args[0]
+    redis.execute("SET", key, value)
     res = redis.execute("GET", key)
     redis.execute("DEL", key)
     return redis_string_float_to_tensor(res)
 
-def test_int_list(key:str, l:List[str]):
-    for value in l:
+def test_int_list(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    for value in args:
         redis.execute("RPUSH", key, value)
-    res = redis.execute("LRANGE", key, "0", str(len(l)))
+    res = redis.execute("LRANGE", key, "0", str(len(args)))
     redis.execute("DEL", key)
     return redis_int_list_to_tensor(res)
 
 
-def test_str_list(key:str, l:List[str]):
-    for value in l:
+def test_str_list(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    for value in args:
         redis.execute("RPUSH", key, value)
 
 
-def test_hash(key:str, l:List[str]):
-    args = [key]
-    for s in l:
-        args.append(s)
-    redis.execute("HSET", args)
+def test_hash(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    command_args = [key]
+    for s in args:
+        command_args.append(s)
+    redis.execute("HSET", command_args)
     res = redis.execute("HVALS", key)
     redis.execute("DEL", key)
     return redis_hash_to_tensor(res)
 
 
-def test_set_key(key:str, value:str):
+def test_set_key(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
+    value = args[0]
     redis.execute("SET", [key, value])
 
 
-def test_del_key(key:str):
+def test_del_key(tensors: List[Tensor], keys: List[str], args: List[str]):
+    key = keys[0]
     redis.execute("DEL", [key])
 
 
-def test_model_execute(keys:List[str]):
+def test_model_execute(tensors: List[Tensor], keys: List[str], args: List[str]):
     a = torch.tensor([[2.0, 3.0], [2.0, 3.0]])
     b = torch.tensor([[2.0, 3.0], [2.0, 3.0]])
     return redisAI.model_execute(keys[0], [a, b], 1)  # assume keys[0] is the model key name saved in redis
 
 
-def test_model_execute_onnx(keys:List[str]):
+def test_model_execute_onnx(tensors: List[Tensor], keys: List[str], args: List[str]):
     a = torch.tensor([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
     return redisAI.model_execute(keys[0], [a], 1)  # assume keys[0] is the model key name saved in redis
 
 
-def test_model_execute_onnx_bad_input(keys:List[str]):
+def test_model_execute_onnx_bad_input(tensors: List[Tensor], keys: List[str], args: List[str]):
     a = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
     return redisAI.model_execute(keys[0], [a], 1)  # assume keys[0] is the model key name saved in redis
diff --git a/tests/flow/test_data/script.txt b/tests/flow/test_data/script.txt
index f6cd1d6a2..4478acc26 100644
--- a/tests/flow/test_data/script.txt
+++ b/tests/flow/test_data/script.txt
@@ -1,8 +1,9 @@
-def bar(a, b):
+def bar(tensors: List[Tensor], keys: List[str], args: List[str]):
+    a = tensors[0]
+    b = tensors[1]
     return a + b
 
-def bar_variadic(a, args : List[Tensor]):
-    return args[0] + args[1]
-
-def bar_two_lists(a: List[Tensor], b:List[Tensor]):
-    return a[0] + b[0]
+def bar_variadic(tensors: List[Tensor], keys: List[str], args: List[str]):
+    a = tensors[0]
+    l = tensors[1:]
+    return a + l[0]
diff --git a/tests/flow/test_data/script_bad.txt b/tests/flow/test_data/script_bad.txt
new file mode 100644
index 000000000..2072eccb5
--- /dev/null
+++ b/tests/flow/test_data/script_bad.txt
@@ -0,0 +1,9 @@
+def bar(tensors: List[Tensor], keys: List[str], args: List[Tensor]):
+    a = tensors[0]
+    b = tensors[1]
+    return a + b
+
+def bar_variadic(tensors: List[Tensor], keys: List[str], args: List[str]):
+    a = tensors[0]
+    l = tensors[1:]
+    return a + l[0]
diff --git a/tests/flow/test_serializations.py b/tests/flow/test_serializations.py
index cec3923c9..e185f7ee4 100644
--- a/tests/flow/test_serializations.py
+++ b/tests/flow/test_serializations.py
@@ -87,8 +87,8 @@ def test_v0_troch_script(self):
         con = self.env.getConnection()
         script_rdb = b'\x07\x81\x00\x8f\xd2\t\x12\x0fL\x00\x05\x04CPU\x00\x05\x10TORCH_SCRIPT_V0\x00\x05\xc3@W@i\x0fdef bar(a, b):\n  \x00\x0ereturn a + b\n\nd\x80 \x08_variadic@)\x12args : List[Tensor]\xe0\x06;  \x02[0] A`\t\x031]\n\x00\x00\t\x00\x0b\xee\x04\xe7\x11\xaez\x91'
         con.restore(key_name, 0, script_rdb, True)
-        _, device, _, tag = con.execute_command("AI.SCRIPTGET", key_name, "META")
-        self.env.assertEqual([device, tag], [b"CPU", b"TORCH_SCRIPT_V0"])  
+        _, device, _, tag, _, entry_points = con.execute_command("AI.SCRIPTGET", key_name, "META")
+        self.env.assertEqual([device, tag, entry_points], [b"CPU", b"TORCH_SCRIPT_V0", []])  
         torch_script_run(self.env, key_name)
 
     def test_v0_onnx_model(self):
@@ -140,8 +140,8 @@ def test_v1_troch_script(self):
         con = self.env.getConnection()
         script_rdb = b'\x07\x81\x00\x8f\xd2\t\x12\x0fL\x01\x05\x04CPU\x00\x05\x0fTORCH_SCRIPT_V1\x05\xc3@W@i\x0fdef bar(a, b):\n  \x00\x0ereturn a + b\n\nd\x80 \x08_variadic@)\x12args : List[Tensor]\xe0\x06;  \x02[0] A`\t\x031]\n\x00\x00\t\x00w\x87\r5\x02\x1b_\xfb'
         con.restore(key_name, 0, script_rdb, True)
-        _, device, _, tag = con.execute_command("AI.SCRIPTGET", key_name, "META")
-        self.env.assertEqual([device, tag], [b"CPU", b"TORCH_SCRIPT_V1"])  
+        _, device, _, tag, _, entry_points = con.execute_command("AI.SCRIPTGET", key_name, "META")
+        self.env.assertEqual([device, tag, entry_points], [b"CPU", b"TORCH_SCRIPT_V1", []])  
         torch_script_run(self.env, key_name)
 
     def test_v1_onnx_model(self):
@@ -194,8 +194,8 @@ def test_v2_troch_script(self):
         con = self.env.getConnection()
         script_rdb = b'\x07\x81\x00\x8f\xd2\t\x12\x0fL\x01\x05\x04CPU\x00\x05\x0fTORCH_SCRIPT_V1\x05\xc3@W@i\x0fdef bar(a, b):\n  \x00\x0ereturn a + b\n\nd\x80 \x08_variadic@)\x12args : List[Tensor]\xe0\x06;  \x02[0] A`\t\x031]\n\x00\x00\t\x00w\x87\r5\x02\x1b_\xfb'
         con.restore(key_name, 0, script_rdb, True)
-        _, device, _, tag = con.execute_command("AI.SCRIPTGET", key_name, "META")
-        self.env.assertEqual([device, tag], [b"CPU", b"TORCH_SCRIPT_V1"])
+        _, device, _, tag, _, entry_points = con.execute_command("AI.SCRIPTGET", key_name, "META")
+        self.env.assertEqual([device, tag, entry_points], [b"CPU", b"TORCH_SCRIPT_V1", []])
         torch_script_run(self.env, key_name)
 
     def test_v2_onnx_model(self):
@@ -218,6 +218,60 @@ def test_v2_tensor(self):
         values = con.execute_command('AI.TENSORGET', key_name, 'VALUES')
         self.env.assertEqual(values, [1, 2])
 
+class test_v3_rdb_load:
+
+    def __init__(self):
+        self.env = Env()
+
+    def test_v3_tf_model(self):
+        key_name = "tf_graph{1}"
+        con = self.env.getConnection()
+        model_rdb = b"\x07\x81\x00\x8f\xff0\xe0\xc4,\x03\x02\x00\x05\x04CPU\x00\x05\x0bTF_GRAPH_V3\x02\x04\x02\x02\x02C\xe8\x02\x02\x05\x02a\x00\x05\x02b\x00\x02\x01\x05\x04mul\x00\x02@\x96\x02\x01\x05\xc3@j@\x96\x1f\n,\n\x01a\x12\x0bPlaceholder*\x0b\n\x05dtype\x12\x020\x01*\x05\r\n\x05sha \x0c\x05\x04:\x02\x18\x01\n -\x00b\xe0!-\x15\x19\n\x03mul\x12\x03Mul\x1a\x01a\x1a\x01b*\x07\n\x01T@W\x0f\n\x1b\n\x01c\x12\x08Identity\x1a@'\xe0\x00\x1c\x01\x12\x00\x00\t\x00\x80T\xc7\x8aM\x88\x94\xd1"
+        self.env.assertEqual(con.execute_command('FLUSHALL'), True)
+        con.restore(key_name, 0, model_rdb, True)
+        _, backend, _, device, _, tag, _, batchsize, _, minbatchsize, _, inputs, _, outputs, _, minbatchtimeout = con.execute_command("AI.MODELGET", key_name, "META")
+        self.env.assertEqual([backend, device, tag, batchsize, minbatchsize, minbatchtimeout, inputs, outputs], [b"TF", b"CPU", b"TF_GRAPH_V3", 4, 2, 1000, [b"a", b"b"], [b"mul"]])
+        tf_model_run(self.env, key_name)
+
+    def test_v3_torch_model(self):
+        key_name = "pt_minimal{1}"
+        con = self.env.getConnection()
+        model_rdb = b'\x07\x81\x00\x8f\xff0\xe0\xc4,\x03\x02\x02\x05\x04CPU\x00\x05\rPT_MINIMAL_V3\x02\x04\x02\x02\x02C\xe8\x02\x02\x05\x02a\x00\x05\x02b\x00\x02\x01\x05\x01\x00\x02EH\x02\x01\x05\xc3C\x0eEH\x0ePK\x03\x04\x00\x00\x08\x08\x00\x00\x86\xb0zO\x00\xe0\x02\x00\x1a\x12\x00\x10\x00pt-minimal/versionFB\x0c\x00Z\xe0\x02\x00\n1\nPK\x07\x08S\xfcQg\x02 ;@\x03\x00P Q\x00\x14 Q\x00\x08\xe0\x08Q\x02\x1c\x004\xe0\x03Q\x13code/__torch__.pyFB0\xe0\x04[\xe0\x1b\x00\x1f5LK\n\x830\x10\xdd{\x8a\xb7T\xb0\x82\xdb\x80\xbd\x81\xbb\xeeJ\t\xa3\x19\xab\x90fd\x12[z\xfb\x1f\x06\xad\xab\xf7\x7f\xb2\xda7k\\$\xd8\xc8\t\x1d\xdab\xf4\x14#\xfao/n\xf3\\\x1eP\x99\x02\xb0v\x1f%\xa5\x17\xa7\xbc\xb06\x97\xef\x8f\xec&\xa5%,\xe1\t\x83A\xc4g\xc7\xf1\x84I\xf4C\xea\xca\xc8~2\x1fy\x99D\xc7\xd9\xda\xe6\xfc\xads\x0f \x83\x1b\x87(z\xc8\xe1\x94\x15.\xd7?5{\xa2\x9c6\r\xd8_\r\x1ar\xae\xa4\x1aC\r\xf2\xebL][\x15?A\x0b\x04a\xc1#I\x8e!\x0b\x00\xc8 \x03\xe1\x11\x0b\x02&\x00\x1e\xe1\x14\x0b\x0c.debug_pklFB\x1a\xe1\x12\x15\x1f5\x8eA\n\xc20\x10EcU\x90\x82+/0\xcb\x8a%\x07p\xe5V\x06t\xdb\x9d\xa4mB"m\xd3\x1f\xa4\x11q\xe7\xca\x1e\xc7S\xa8\xd72)\xe4m\x06\xde\x87?\xff\x99d\xb8)\x88\xc7\x10I\x90\x8cf\x86\xe1\x1f\xbc\xf0]\x9c\xbd\x05\xcf\xc1i[IzU\x8e\x0e\x95U\xbd\xbb\xb4\xdcI]\xa7!\xac\xb9\x00\xa1\xed\x9d\xd9\x1f:\x1bx#r`9\x94\xdb\xfd\x14\x06,w7\xdb\x01\x83\x1d\x94\xa9I\x8a\xb5o\r\x15\xaaS-kh\x15\xff0s\\\x8df\x81G<\xf9\xb7\x1f\x19\x07|et\xbf\xe8\x9cY\xd2a\x08\x04\xa7\x94\x1a\x02\x97!\x04\x00\xb2 \x03A\x08\xe2\rf\x02\x18\x00#\xe1\x05\x08\x07nstants.`\xfa\x00\x1f\xe0\x12\xfa`\x00\x03\x80\x02).Au\x03m/\tW a\x00\x00@\x03\xe0\x11l\x02\x13\x00;\xe0\x03l\x03data\x80g\x007\xe0\x17g\xe0\x0f\x00\x02\x80\x02c\xe2\x00\xc2\x10\nMyModule\nq\x00)\x81}(X#U\x0f\x00trainingq\x01\x88ubq\x02`\xac\x04z\xb8\x18\x811 \x1b@\x03\x02PK\x01C5#0\x83\x82\xe3\x03J\x00\x12 \x17\xe0\x05\x00\xe3\t\x90\x80?\xe3\x01p\xe2\x03~\x00\x1c\xe0\x04<\x00R \r\xe0\x02?\xe3\x08~\xe0\x07I\xe1\x03\xbf\x00& ;\xe0\x01\x00\x01^\x01\xe0\x15I\xe2\x01\xbc\x80S\xe0\x01\xdd\xe1\x03\xa6\x00\x18 \x17\xe0\x01\x00D?\xe0\x04\x9d\xe2\x02\x07\xe0\x07E\xe1\x03?\x00\x13\xe0\x01B \x00\x00\xd4!K\xe0\x02E\xc1\xe0\x04PK\x06\x06, \x1e@\x00\x02\x1e\x03-@\x06`\x00\x00\x05`\x05\xe0\x01\x07\x00e \xd8@\x00\x01\x81\x03@\x05A\x9c\x01\x06\x07 \x06\x01\x00\xe6BV \x00@\x1e\x03PK\x05\x06 \n ;\x00\x05`/@+\x01\x00\x00\x00\t\x00\x99\xc0*\x8a\xdf\xb3\x07\xc3'
+        self.env.assertEqual(con.execute_command('FLUSHALL'), True)
+        con.restore(key_name, 0, model_rdb, True)
+        _, backend, _, device, _, tag, _, batchsize, _, minbatchsize, _ , inputs, _, outputs,  _, minbatchtimeout = con.execute_command("AI.MODELGET", key_name, "META")
+        self.env.assertEqual([backend, device, tag, batchsize, minbatchsize, minbatchtimeout, inputs, outputs], [b"TORCH", b"CPU", b"PT_MINIMAL_V3", 4, 2, 1000, [b'a', b'b'], [b'']])
+        torch_model_run(self.env, key_name)
+
+    def test_v3_troch_script(self):
+        key_name = "torch_script{1}"
+        con = self.env.getConnection()
+        script_rdb =b'\x07\x81\x00\x8f\xd2\t\x12\x0fL\x03\x05\x04CPU\x00\x05\x0fTORCH_SCRIPT_V3\x05\xc3@|A\x01\x16def bar(tensors: List[T`\r\x05], key\xc0\x13\x01st@\x10\x02arg\xe0\x03\x10\x03):\n  \x00\x03a = \xa0A\x02[0]`\x12\x00b\xe0\x02\x12\x001\x80\x12\x05return ,\x05+ b\n\nd\x80y\x08_variadic\xe0I\x82\x00l\xe0\x03\x82\x00:\xe0\x08\x83\x00l \xaa\x01\n\x00\x02\x02\x05\x04bar\x00\x05\rbar_variadic\x00\x00\t\x00\xd3\x88D\xce3ek\x01'
+        con.restore(key_name, 0, script_rdb, True)
+        _, device, _, tag, _, entry_points = con.execute_command("AI.SCRIPTGET", key_name, "META")
+        self.env.assertEqual([device, tag, entry_points], [b"CPU", b"TORCH_SCRIPT_V3", [b'bar', b'bar_variadic']])
+        torch_script_run(self.env, key_name)
+
+    def test_v3_onnx_model(self):
+        key_name = "linear_iris{1}"
+        con = self.env.getConnection()
+        model_rdb = b'\x07\x81\x00\x8f\xff0\xe0\xc4,\x03\x02\x03\x05\x04CPU\x00\x05\x13ONNX_LINEAR_IRIS_V3\x02\x04\x02\x02\x02C\xe8\x02\x01\x05\x0cfloat_input\x00\x02\x01\x05\tvariable\x00\x02A\x15\x02\x01\x05\xc3@\xe6A\x15\x17\x08\x05\x12\x08skl2onnx\x1a\x051.4.9"\x07ai.@\x0f\x1f(\x002\x00:\xe2\x01\n\x82\x01\n\x0bfloat_input\x12\x08variabl\x12e\x1a\x0fLinearRegressor"\xe0\x07\x10\x1f*%\n\x0ccoefficients=K\xfe\xc2\xbd=\xf7\xbe\x1c\xbd=/ii>=\x12\xe81\x1a?\xa0\x01\x06*\x14\n\nintercep $\x03\xa8\x1d\xb7= \x15\x01:\n\xa0\x88\x1f.ml\x12 2d76caf265cd4138a74199640a1\x06fc408Z\x1d\xe0\x05\xa5\n\x0e\n\x0c\x08\x01\x12\x08\n\x02\x08\x01 \x03\x03\x04b\x1a\n\xe0\x00\xb7\xe0\x06\x1b\x03\x01B\x0e\n\xe0\x02j\x01\x10\x01\x00\t\x00x\xf2\xe7be\x8b\xc1\xdc'
+        self.env.assertEqual(con.execute_command('FLUSHALL'), True)
+        con.restore(key_name, 0, model_rdb, True)
+        _, backend, _, device, _, tag, _, batchsize, _, minbatchsize, _ , inputs, _, outputs, _, minbatchtimeout = con.execute_command("AI.MODELGET", key_name, "META")
+        self.env.assertEqual([backend, device, tag, batchsize, minbatchsize, minbatchtimeout, inputs, outputs], [b"ONNX", b"CPU", b"ONNX_LINEAR_IRIS_V3", 4, 2, 1000, [b'float_input'], [b'variable']])
+        onnx_model_run(self.env, key_name)
+
+    def test_v3_tensor(self):
+        key_name = "tensor{1}"
+        con = self.env.getConnection()
+        tensor_rdb = b'\x07\x81\x00\x8f\xd3\x10\xd4\x8eD\x03\x02\x01\x02\x00\x02 \x02\x00\x02\x01\x02\x02\x02\x02\x02\x01\x02\x01\x02\x01\x02\x00\x05\x08\x01\x00\x00\x00\x02\x00\x00\x00\x00\t\x00\x00\xed/\xf8h\xec\xd7\xf6'
+        con.restore(key_name, 0, tensor_rdb, True)
+        _, tensor_type, _, tensor_shape = con.execute_command('AI.TENSORGET', key_name, 'META')
+        self.env.assertEqual([tensor_type, tensor_shape], [b"INT32", [2, 1]])
+        values = con.execute_command('AI.TENSORGET', key_name, 'VALUES')
+        self.env.assertEqual(values, [1, 2])
+
 
 class TestAofRewrite:
 
@@ -315,12 +369,12 @@ def test_aof_rewrite_troch_script(self):
         key_name = "torch_script{1}"
         con = self.env.getConnection()
         torch_script = load_file_content("script.txt")
-        con.execute_command('AI.SCRIPTSET', key_name, 'CPU', 'TAG', 'TORCH_SCRIPT', 'SOURCE', torch_script)
+        con.execute_command('AI.SCRIPTSTORE', key_name, 'CPU', 'TAG', 'TORCH_SCRIPT', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', torch_script)
 
         # Redis should save the stored script by calling the AOF rewrite callback and then reload from AOF.
         self.env.restartAndReload()
-        _, device, _, tag = con.execute_command("AI.SCRIPTGET", key_name, "META")
-        self.env.assertEqual([device, tag], [b"CPU", b"TORCH_SCRIPT"])
+        _, device, _, tag, _, entry_points = con.execute_command("AI.SCRIPTGET", key_name, "META")
+        self.env.assertEqual([device, tag, entry_points], [b"CPU", b"TORCH_SCRIPT", [b'bar', b'bar_variadic']])
         torch_script_run(self.env, key_name)
 
     def test_aof_rewrite_onnx_model(self):
diff --git a/tests/flow/test_torchscript_extensions.py b/tests/flow/test_torchscript_extensions.py
index a7cddeaf9..9bb08623b 100644
--- a/tests/flow/test_torchscript_extensions.py
+++ b/tests/flow/test_torchscript_extensions.py
@@ -21,7 +21,21 @@ def __init__(self):
         self.con = self.env.getConnection()
         script = load_file_content('redis_scripts.py')
         ret = self.con.execute_command(
-            'AI.SCRIPTSET', 'redis_scripts{1}', DEVICE, 'SOURCE', script)
+            'AI.SCRIPTSTORE', 'redis_scripts{1}', DEVICE, 'ENTRY_POINTS', 13, 
+            'test_redis_error',
+            'test_set_key', 
+            'test_int_set_get', 
+            'test_int_set_incr', 
+            'test_float_set_get', 
+            'test_int_list', 
+            'test_str_list', 
+            'test_hash', 
+            'test_model_execute', 
+            'test_model_execute_onnx', 
+            'test_model_execute_onnx_bad_input',
+            'test_redis_command_error',
+            'test_redis_error_message',
+            'SOURCE', script)
         self.env.assertEqual(ret, b'OK')
         model_tf = load_file_content('graph.pb')
         ret = self.con.execute_command('AI.MODELSTORE', 'model_tf{1}', 'TF', DEVICE, 'INPUTS', 2, 'a', 'b', 'OUTPUTS', 1,
@@ -37,30 +51,29 @@ def __init__(self):
 
     def test_redis_error(self):
         check_error_message(self.env, self.con, "Redis command returned an error: Invalid argument",
-                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_redis_command_error',  'KEYS', 1, "x{1}",
-                            "INPUTS", 1, "x{1}",  error_msg_is_substr=True)
+                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_redis_command_error',  'KEYS', 1, "x{1}", error_msg_is_substr=True)
         check_error_message(self.env, self.con, "Redis command returned an error: "
                                                 "WRONGTYPE Operation against a key holding the wrong kind of value",
-                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_redis_error_message',  'KEYS', 1, "hash{1}",
-                            "INPUTS", 1, "hash{1}",  error_msg_is_substr=True)
+                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_redis_error_message',  'KEYS', 1, "hash{1}",  error_msg_is_substr=True)
+
         
     def test_simple_test_set(self):
         self.con.execute_command(
-            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_set_key', 'KEYS', 1, "x{1}", "INPUTS", 2, "x{1}", 1)
+            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_set_key', 'KEYS', 1, "x{1}", "ARGS", 1, 1)
         self.env.assertEqual(b"1", self.con.get("x{1}"))
 
     def test_int_set_get(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_set_get', 'KEYS', 1, "x{1}", "INPUTS", 2, "x{1}", 1, 'OUTPUTS', 1, 'y{1}')
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_set_get', 'KEYS', 1, "x{1}", "ARGS", 1, 1, 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta' ,'VALUES')
         self.env.assertEqual(y, [b"dtype", b"INT64", b"shape", [], b"values", [1]] )
 
     def test_int_set_incr(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_set_incr', 'KEYS', 1, "x{1}", "INPUTS", 2, "x{1}", 1, 'OUTPUTS', 1, 'y{1}')
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_set_incr', 'KEYS', 1, "x{1}", "ARGS", 1, 1, 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta' ,'VALUES')
         self.env.assertEqual(y, [b"dtype", b"INT64", b"shape", [], b"values", [2]] )
 
     def test_float_get_set(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_float_set_get', 'KEYS', 1, "x{1}", "INPUTS", 2, "x{1}", 1.1, 'OUTPUTS', 1, 'y{1}')
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_float_set_get', 'KEYS', 1, "x{1}", "ARGS", 1, 1.1, 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta' ,'VALUES')
         self.env.assertEqual(y[0], b"dtype")
         self.env.assertEqual(y[1], b"FLOAT")
@@ -70,47 +83,47 @@ def test_float_get_set(self):
         self.env.assertAlmostEqual(float(y[5][0]), 1.1, 0.1)
 
     def test_int_list(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_list', 'KEYS', 1, "int_list{1}", 'INPUTS', 1, "int_list{1}", "LIST_INPUTS", 2, "1", "2", 'OUTPUTS', 1, 'y{1}')
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_int_list', 'KEYS', 1, "int_list{1}", 'ARGS', 2, 1, 2, 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta' ,'VALUES')
         self.env.assertEqual(y, [b"dtype", b"INT64", b"shape", [2, 1], b"values", [1, 2]] )
 
     def test_str_list(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_str_list', 'KEYS', 1, "str_list{1}", 'INPUTS', 1, "str_list{1}", "LIST_INPUTS", 2, "1", "2")
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_str_list', 'KEYS', 1, "str_list{1}", "ARGS", 2, "1", "2")
         res = self.con.execute_command("LRANGE", "str_list{1}", "0", "2")
         self.env.assertEqual(res, [b"1", b"2"] )
 
     def test_hash(self):
-        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_hash', 'KEYS', 1, "hash{1}", 'INPUTS', 1, "hash{1}", "LIST_INPUTS", 4, "field1", 1, "field2", 2, 'OUTPUTS', 1, 'y{1}')
+        self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_hash', 'KEYS', 1, "hash{1}", "ARGS", 4, "field1", 1, "field2", 2, 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta' ,'VALUES')
         self.env.assertEqual(y, [b"dtype", b"INT64", b"shape", [2, 1], b"values", [1, 2]])
 
     def test_execute_model_via_script(self):
         # run torch model
         self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute', 'KEYS', 1, "model_torch{1}",
-                                 'LIST_INPUTS', 1, 'model_torch{1}', 'OUTPUTS', 1, 'y{1}')
+                                 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta', 'VALUES')
         self.env.assertEqual(y, [b"dtype", b"FLOAT", b"shape", [2, 2], b"values", [b'4', b'6', b'4', b'6']])
 
         # run tf model
         self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute', 'KEYS', 1, "model_tf{1}",
-                                 'LIST_INPUTS', 1, 'model_tf{1}', 'OUTPUTS', 1, 'y{1}')
+                                 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta', 'VALUES')
         self.env.assertEqual(y, [b"dtype", b"FLOAT", b"shape", [2, 2], b"values", [b'4', b'9', b'4', b'9']])
 
         # run onnx model
         self.con.execute_command('AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute_onnx', 'KEYS', 1, "model_onnx{1}",
-                                 'LIST_INPUTS', 1, 'model_onnx{1}', 'OUTPUTS', 1, 'y{1}')
+                                 'OUTPUTS', 1, 'y{1}')
         y = self.con.execute_command('AI.TENSORGET', 'y{1}', 'meta', 'VALUES')
         self.env.assertEqual(y, [b"dtype", b"FLOAT", b"shape", [3, 2], b"values", [b'1', b'4', b'9', b'16', b'25', b'36']])
 
     def test_execute_model_via_script_errors(self):
         # Trying to run a non-existing model
         check_error_message(self.env, self.con, "ERR model key is empty",
-                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute_onnx', 'KEYS', 1, "{1}",
-                            'LIST_INPUTS', 1, 'bad_model{1}', 'OUTPUTS', 1, 'y{1}', error_msg_is_substr=True)
+                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute_onnx', 'KEYS', 1, "bad_model{1}",
+                            'OUTPUTS', 1, 'y{1}', error_msg_is_substr=True)
 
         # Runtime error while executing the model - input tensor's dim is not compatible with model.
         check_error_message(self.env, self.con,
                             "Invalid rank for input: X Got: 1 Expected: 2 Please fix either the inputs or the model",
-                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute_onnx_bad_input', 'KEYS', 1, "{1}",
-                            'LIST_INPUTS', 1, 'model_onnx{1}', 'OUTPUTS', 1, 'y{1}', error_msg_is_substr=True)
+                            'AI.SCRIPTEXECUTE', 'redis_scripts{1}', 'test_model_execute_onnx_bad_input', 'KEYS', 1, "model_onnx{1}",
+                            'OUTPUTS', 1, 'y{1}', error_msg_is_substr=True)
diff --git a/tests/flow/tests_commands.py b/tests/flow/tests_commands.py
index 78d83de7a..683dae74b 100644
--- a/tests/flow/tests_commands.py
+++ b/tests/flow/tests_commands.py
@@ -143,7 +143,7 @@ def test_keys_syntax(env):
 
     con = env.getConnection()
     script = load_file_content('script.txt')
-    ret = con.execute_command('AI.SCRIPTSET', 'script{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'script{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     # ERR wrong number of arguments for KEYS
@@ -161,18 +161,177 @@ def test_keys_syntax(env):
                                   "of given arguments",
                         "AI.SCRIPTEXECUTE script{1} bar KEYS 2 key{1}")
 
-    # ERR KEYS missing in AI.SCRIPTEXECUTE
-    check_error_message(env, con, "KEYS scope must be provided first for AI.SCRIPTEXECUTE command",
-                        "AI.SCRIPTEXECUTE script{1} bar INPUTS 2 a{1} a{1}")
+    # ERR KEYS or INPUTS missing in AI.SCRIPTEXECUTE
+    check_error_message(env, con, "KEYS or INPUTS scope must be provided first for AI.SCRIPTEXECUTE command",
+                        "AI.SCRIPTEXECUTE script{1} bar OUTPUTS 2 a{1} a{1}")
 
-    # ERR KEYS section in an inner AI.SCRIPTEXEUTE command within a DAG is not allowed.
-    check_error_message(env, con, "Already encountered KEYS scope in current command",
-                        "AI.DAGEXECUTE KEYS 1 a{1} |> AI.SCRIPTEXECUTE script{1} bar KEYS 1 a{1}")
 
-
-# Todo: this test should change once the script store command is implemented.
 def test_scriptstore(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
     con = env.getConnection()
     script = load_file_content('script.txt')
-    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'SOURCE', script)
+
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'TAG', 'asdf', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+def test_scriptstore_errors(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
+    con = env.getConnection()
+    script = load_file_content('script.txt')
+    old_script = load_file_content('old_script.txt')
+    bad_script = load_file_content('script_bad.txt')
+
+    check_error_message(env, con, "wrong number of arguments for 'AI.SCRIPTSTORE' command", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'SOURCE', 'return 1')
+
+    check_error_message(env, con, "wrong number of arguments for 'AI.SCRIPTSTORE' command", 'AI.SCRIPTSTORE', 'nope')
+
+    check_error_message(env, con, "wrong number of arguments for 'AI.SCRIPTSTORE' command", 'AI.SCRIPTSTORE', 'nope', 'SOURCE')
+
+    check_error_message(env, con, "wrong number of arguments for 'AI.SCRIPTSTORE' command", 'AI.SCRIPTSTORE', 'more', DEVICE)
+
+    check_error_message(env, con, "Insufficient arguments, missing script entry points", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'NO_ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
+
+    check_error_message(env, con, "Non numeric entry points number provided to AI.SCRIPTSTORE command", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 'ENTRY_POINTS', 'bar', 'bar_variadic', 'SOURCE', script)
+
+    check_error_message(env, con, "Function bar1 does not exist in the given script.", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar1', 'SOURCE', script)
+
+    check_error_message(env, con, "Insufficient arguments, missing script SOURCE", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE')
+
+    check_error_message(env, con, "Wrong number of inputs in function bar. Expected 3 but was 2", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', old_script)
+
+    check_error_message(env, con, "Wrong inputs type in function bar. Expected signature similar to: def bar(tensors: List[Tensor], keys: List[str], args: List[str])", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', bad_script)
+
+    check_error_message(env, con, "Insufficient arguments, missing script entry points", 'AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 5 , 'bar', 'bar_variadic', 'SOURCE', script)
+
+
+def test_pytrorch_scriptget_errors(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
+    con = env.getConnection()
+
+    script = load_file_content('script.txt')
+
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+    ret = con.execute_command('AI.TENSORSET', 'b{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+    # ERR no script at key from SCRIPTGET
+    check_error_message(env, con, "script key is empty", 'AI.SCRIPTGET', 'EMPTY{1}')
+
+    con.execute_command('SET', 'NOT_SCRIPT{1}', 'BAR')
+    # ERR wrong type from SCRIPTGET
+    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTGET', 'NOT_SCRIPT{1}')
+
+
+def test_pytorch_scriptexecute_errors(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
+    con = env.getConnection()
+
+    script = load_file_content('script.txt')
+
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+    ret = con.execute_command('AI.TENSORSET', 'b{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+    con.execute_command('DEL', 'EMPTY{1}')
+    # ERR no script at key from SCRIPTEXECUTE
+    check_error_message(env, con, "script key is empty", 'AI.SCRIPTEXECUTE', 'EMPTY{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    con.execute_command('SET', 'NOT_SCRIPT{1}', 'BAR')
+    # ERR wrong type from SCRIPTEXECUTE
+    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'NOT_SCRIPT{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    con.execute_command('DEL', 'EMPTY{1}')
+    # ERR Input key is empty
+    check_error_message(env, con, "tensor key is empty or in a different shard", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'EMPTY{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    con.execute_command('SET', 'NOT_TENSOR{1}', 'BAR')
+    # ERR Input key not tensor
+    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'NOT_TENSOR{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'a{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 'OUTPUTS')
+
+    check_error_message(env, con, "Invalid arguments provided to AI.SCRIPTEXECUTE", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1, '{1}', 'ARGS')
+
+    check_error_message(env, con, "Invalid argument for inputs count in AI.SCRIPTEXECUTE", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'INPUTS', 'OUTPUTS')
+
+    check_error_message(env, con, "Invalid value for TIMEOUT",'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1, '{1}', 'INPUTS', 2, 'a{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}', 'TIMEOUT', 'TIMEOUT')
+
+
+    if env.isCluster():
+        # cross shard
+        check_error_message(env, con, "CROSSSLOT Keys in request don't hash to the same slot", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{2}', 'INPUTS', 2, 'a{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
+
+        # key doesn't exist
+        check_error_message(env, con, "CROSSSLOT Keys in request don't hash to the same slot", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'a{1}', 'b{2}', 'OUTPUTS', 1, 'c{1}')
+
+
+def test_pytorch_scriptexecute_variadic_errors(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
+    con = env.getConnection()
+
+    script = load_file_content('script.txt')
+
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{$}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ret = con.execute_command('AI.TENSORSET', 'a{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+    ret = con.execute_command('AI.TENSORSET', 'b{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+    con.execute_command('DEL', 'EMPTY{$}')
+    # ERR Variadic input key is empty
+    check_error_message(env, con, "tensor key is empty or in a different shard", 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 3, 'a{$}', 'EMPTY{$}', 'b{$}', 'OUTPUTS', 1, 'c{$}')
+
+    con.execute_command('SET', 'NOT_TENSOR{$}', 'BAR')
+    # ERR Variadic input key not tensor
+    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 3, 'a{$}', 'NOT_TENSOR{$}', 'b{$}', 'OUTPUTS', 1, 'c{$}')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 2, 'b{$}', '${$}', 'OUTPUTS', 1, 'c{$}')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 1, 'b{$}', 'OUTPUTS')
+
+    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 'OUTPUTS')
+
diff --git a/tests/flow/tests_dag.py b/tests/flow/tests_dag.py
index f99c9c08e..b1070af88 100644
--- a/tests/flow/tests_dag.py
+++ b/tests/flow/tests_dag.py
@@ -35,7 +35,7 @@ def test_dagrun_modelexecute_scriptexecute_resnet(env):
                               'BLOB', model_pb)
     env.assertEqual(ret, b'OK')
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name, DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name, DEVICE, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     for opnumber in range(1,100):
@@ -382,29 +382,31 @@ def test_dagexecute_modelexecute_multidevice_resnet(env):
 
     ensureSlaveSynced(con, env)
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name, device_0, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name, device_0, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
 
     check_error_message(env, con, "INPUT key cannot be found in DAG",
-                        'AI.DAGEXECUTE', 'KEYS', '1', image_key, '|>', 'AI.SCRIPTEXECUTE',  script_name, 'pre_process_3ch',
+                        'AI.DAGEXECUTE', 'ROUTING', image_key, '|>', 'AI.SCRIPTEXECUTE',  script_name, 'pre_process_3ch',
                         'INPUTS', 1, image_key, 'OUTPUTS', 1, temp_key1)
 
     check_error_message(env, con, "INPUT key cannot be found in DAG",
-                        'AI.DAGEXECUTE', 'KEYS', '1', image_key, '|>', 'AI.MODELEXECUTE', model_name_0,
+                        'AI.DAGEXECUTE', 'ROUTING',  image_key, '|>', 'AI.MODELEXECUTE', model_name_0,
                         'INPUTS', 1, image_key, 'OUTPUTS', 1, temp_key1)
 
-    check_error_message(env, con, "Wrong function name given to AI.SCRIPTEXECUTE command",
-                        'AI.DAGEXECUTE', 'KEYS', 1, '{1}',
-                        '|>', 'AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes(),
-                        '|>',
-                        'AI.SCRIPTEXECUTE',  script_name, 'wrong_fn',
-                        'INPUTS', 1, image_key,
-                        'OUTPUTS', 1, temp_key1)
+    ret = con.execute_command('AI.DAGEXECUTE', 
+                            'ROUTING', '{1}','|>',
+                            'AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes(),'|>',
+                            'AI.SCRIPTEXECUTE',  script_name, 'wrong_fn',
+                            'INPUTS', 1, image_key,
+                            'OUTPUTS', 1, temp_key1)
+    env.assertEquals(b'OK', ret[0])
+    env.assertEquals(type(ret[1]), redis.exceptions.ResponseError)
+    env.assertEquals("Function does not exist: wrong_fn",  ret[1].__str__())
 
     check_error_message(env, con, "Number of keys given as INPUTS here does not match model definition",
-                        'AI.DAGEXECUTE', 'KEYS', 1, '{1}',
+                        'AI.DAGEXECUTE', 'ROUTING', '{1}',
                         '|>', 'AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes(),
                         '|>',
                         'AI.SCRIPTEXECUTE',  script_name, 'pre_process_3ch',
@@ -490,12 +492,12 @@ def test_dagexecute_modelexecute_multidevice_resnet_ensemble_alias(env):
 
     ensureSlaveSynced(con, env)
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name_0, device_0, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name_0, device_0, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name_1, device_1, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name_1, device_1, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
@@ -554,7 +556,7 @@ def test_dagexecute_modelexecute_multidevice_resnet_ensemble_alias(env):
                         'OUTPUTS', 1, class_key_0)
 
     # The 'ensamble' function in script_name_0 expect to receive 2 inputs (not 1)
-    check_error_message(env, con, "Wrong number of inputs provided to AI.SCRIPTEXECUTE command",
+    ret = con.execute_command(
                         'AI.DAGEXECUTE',
                         'PERSIST', '1', class_key_0, '|>',
                         'AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes(),
@@ -579,6 +581,14 @@ def test_dagexecute_modelexecute_multidevice_resnet_ensemble_alias(env):
                         'INPUTS', 1, temp_key1,
                         'OUTPUTS', 1, class_key_0)
 
+    env.assertEquals(b'OK', ret[0])
+    env.assertEquals(b'OK', ret[1])
+    env.assertEquals(b'OK', ret[2])
+    env.assertEquals(b'OK', ret[3])
+    env.assertEquals(b'NA', ret[5])
+    env.assertEqual(type(ret[4]), redis.exceptions.ResponseError)
+    env.assertTrue("list index out of range" in  ret[4].__str__())
+
     ret = con.execute_command(
         'AI.DAGEXECUTE',
                      'PERSIST', '1', class_key_0,
diff --git a/tests/flow/tests_dag_basic.py b/tests/flow/tests_dag_basic.py
index b70872e1c..02b558157 100644
--- a/tests/flow/tests_dag_basic.py
+++ b/tests/flow/tests_dag_basic.py
@@ -19,7 +19,7 @@ def test_dag_load(env):
 def test_dag_local_tensorset(env):
     con = env.getConnection()
 
-    command = "AI.DAGEXECUTE KEYS 1 {1} |> " \
+    command = "AI.DAGEXECUTE ROUTING {1} |> " \
               "AI.TENSORSET volatile_tensor1 FLOAT 1 2 VALUES 5 10 |> " \
               "AI.TENSORSET volatile_tensor2 FLOAT 1 2 VALUES 5 10 "
 
@@ -34,7 +34,7 @@ def test_dag_local_tensorset(env):
 def test_dagro_local_tensorset(env):
     con = env.getConnection()
 
-    command = "AI.DAGEXECUTE_RO KEYS 1 {some_tag} |> " \
+    command = "AI.DAGEXECUTE_RO ROUTING {some_tag} |> " \
               "AI.TENSORSET volatile_tensor1 FLOAT 1 2 VALUES 5 10 |> " \
               "AI.TENSORSET volatile_tensor2 FLOAT 1 2 VALUES 5 10 "
 
@@ -246,7 +246,7 @@ def test_dag_with_error(env):
     # Run the model from DAG context, where MODELEXECUTE op fails due to dim mismatch in one of the tensors inputs:
     # the input tensor 'b' is considered as tensor with dim 2X2X3 initialized with zeros, while the model expects that
     # both inputs to node 'mul' will be with dim 2.
-    ret = con.execute_command('AI.DAGEXECUTE_RO', 'KEYS', 1, '{1}',
+    ret = con.execute_command('AI.DAGEXECUTE_RO', 'ROUTING', '{1}',
                               '|>', 'AI.TENSORSET', 'a', 'FLOAT', 2, 'VALUES', 2, 3,
                               '|>', 'AI.TENSORSET', 'b', 'FLOAT', 2, 2, 3,
                               '|>', 'AI.MODELEXECUTE', 'tf_model{1}', 'INPUTS', 2, 'a', 'b', 'OUTPUTS', 1, 'tD',
diff --git a/tests/flow/tests_dag_errors.py b/tests/flow/tests_dag_errors.py
index f2e39dcfc..4935b3084 100644
--- a/tests/flow/tests_dag_errors.py
+++ b/tests/flow/tests_dag_errors.py
@@ -19,16 +19,16 @@ def test_dag_load_errors(env):
 
     # ERR number of keys to LOAD does not match the number of given arguments.
     check_error_message(env, con, "number of keys to LOAD into DAG does not match the number of given arguments",
-                        "AI.DAGEXECUTE KEYS 1 a{1} LOAD 2 a{1}")
+                        "AI.DAGEXECUTE ROUTING a{1} LOAD 2 a{1}")
 
     # ERR Check key in shard succeeded  but tensor is empty.
     check_error_message(env, con, "tensor key is empty or in a different shard",
-                        "AI.DAGEXECUTE KEYS 1 no_tensor{1} LOAD 1 no_tensor{1}")
+                        "AI.DAGEXECUTE ROUTING no_tensor{1} LOAD 1 no_tensor{1}")
 
     # WRONGTYPE Operation against a key holding the wrong kind of value
     con.execute_command('SET', 'no_tensor{1}', 'value')
     check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value",
-                        "AI.DAGEXECUTE KEYS 1 no_tensor{1} LOAD 1 no_tensor{1}")
+                        "AI.DAGEXECUTE ROUTING no_tensor{1} LOAD 1 no_tensor{1}")
 
 
 def test_dag_persist_errors(env):
@@ -37,15 +37,15 @@ def test_dag_persist_errors(env):
 
     # ERR wrong number of arguments for PERSIST
     check_error_message(env, con, "missing arguments after PERSIST keyword in DAG command",
-                        "AI.DAGEXECUTE KEYS 1 a{1} LOAD 1 a{1} PERSIST 1")
+                        "AI.DAGEXECUTE ROUTING a{1} LOAD 1 a{1} PERSIST 1")
 
     # ERR invalid or negative value found in number of keys to PERSIST
     check_error_message(env, con, "invalid or negative value found in number of keys to PERSIST",
-                        "AI.DAGEXECUTE KEYS 1 a{1} PERSIST not_number a{1}")
+                        "AI.DAGEXECUTE ROUTING a{1} PERSIST not_number a{1}")
 
     # ERR number of keys to PERSIST does not match the number of given arguments.
     check_error_message(env, con, "number of keys to PERSIST after DAG execution does not match the number of given arguments",
-                        "AI.DAGEXECUTE KEYS 1 a{1} PERSIST 2 a{1}")
+                        "AI.DAGEXECUTE ROUTING a{1} PERSIST 2 a{1}")
 
 
 def test_dag_timeout_errors(env):
@@ -53,11 +53,11 @@ def test_dag_timeout_errors(env):
 
     # ERR no value provided for timeout
     check_error_message(env, con, "No value provided for TIMEOUT",
-                        "AI.DAGEXECUTE KEYS 1 a{1} PERSIST 1 a{1} TIMEOUT")
+                        "AI.DAGEXECUTE ROUTING a{1} PERSIST 1 a{1} TIMEOUT")
 
     # ERR invalid timeout value
     check_error_message(env, con, "Invalid value for TIMEOUT",
-                        "AI.DAGEXECUTE KEYS 1 a{1} PERSIST 1 a{1} TIMEOUT not_number")
+                        "AI.DAGEXECUTE ROUTING a{1} PERSIST 1 a{1} TIMEOUT not_number")
 
 
 def test_dag_common_errors(env):
@@ -68,21 +68,25 @@ def test_dag_common_errors(env):
                               'INPUTS', 2, 'a', 'b', 'OUTPUTS', 1, 'mul', 'BLOB', model_pb)
     env.assertEqual(ret, b'OK')
     script = load_file_content('script.txt')
-    ret = con.execute_command('AI.SCRIPTSET', 'script{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'script{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
+
+    check_error_message(env, con, "Missing ROUTING value",
+                        "AI.DAGEXECUTE PERSIST 3 a{1} b{1} c{1} ROUTING")
+
     # ERR bad syntax
     check_error_message(env, con, "Invalid DAG command. Unexpected argument:  BAD_ARG",
-                        "AI.DAGEXECUTE KEYS 1 a{1} PERSIST 1 a{1} BAD_ARG")
+                        "AI.DAGEXECUTE ROUTING a{1} PERSIST 1 a{1} BAD_ARG")
 
-    # ERR DAG doesn't contains none of KEYS, LOAD, PERSIST
+    # ERR DAG doesn't contains none of ROUTING, LOAD, PERSIST
     check_error_message(env, con, "AI.DAGEXECUTE and AI.DAGEXECUTE_RO commands must contain at least one out of"
-                                  " KEYS, LOAD, PERSIST keywords",
+                                  " ROUTING, LOAD, PERSIST keywords",
                         "AI.DAGEXECUTE |> AI.TENSORSET a{1} FLOAT 1 2 VALUES 5 10")
 
     # ERR unsupported command within DAG
     check_error_message(env, con, "Unsupported command within DAG",
-                        "AI.DAGEXECUTE KEYS 1 a{1} |> AI.NOCOMMAND a{1} FLOAT 1 2 VALUES 5 10")
+                        "AI.DAGEXECUTE ROUTING a{1} |> AI.NOCOMMAND a{1} FLOAT 1 2 VALUES 5 10")
 
     # ERR wrong number of arguments for 'AI.DAGEXECUTE' command
     check_error_message(env, con, "missing arguments for 'AI.DAGEXECUTE' command", "AI.DAGEXECUTE ")
@@ -91,7 +95,7 @@ def test_dag_common_errors(env):
     command = "AI.TENSORSET volatile_tensor{1} FLOAT 2 2 VALUES 5 10 5 10"
     ret = con.execute_command(command)
     env.assertEqual(ret, b'OK')
-    check_error_message(env, con, "DAG is empty", "AI.DAGEXECUTE KEYS 1 volatile_tensor{1} LOAD 1 volatile_tensor{1}")
+    check_error_message(env, con, "DAG is empty", "AI.DAGEXECUTE ROUTING volatile_tensor{1} LOAD 1 volatile_tensor{1}")
 
     # ERR Deprecated commands in (non-deprecated) AI.DAGEXECUTE
     check_error_message(env, con, "Deprecated AI.MODELRUN cannot be used in AI.DAGEXECUTE command",
@@ -115,7 +119,7 @@ def test_dag_ro_errors(env):
 
     # ERR AI.SCRIPTEXECUTE is not allowed in AI.DAGEXECUTE_RO
     script = load_file_content('script.txt')
-    ret = con.execute_command('AI.SCRIPTSET', 'script{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'script{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
     ret = con.execute_command("AI.TENSORSET volatile_tensor{1} FLOAT 1 2 VALUES 5 10")
     env.assertEqual(ret, b'OK')
@@ -142,7 +146,7 @@ def test_dag_scriptexecute_errors(env):
                               'BLOB', model_pb)
     env.assertEqual(ret, b'OK')
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name, DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name, DEVICE, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     # The function name in AI.SCRIPTEXECUTE is missing, so 'INPUTS' is considered as the function name, and
@@ -152,7 +156,7 @@ def test_dag_scriptexecute_errors(env):
     temp_key2 = 'temp_key2{1}'
     class_key = 'output{1}'
     command = (
-        'AI.DAGEXECUTE', 'KEYS', 1, '{1}', '|>',
+        'AI.DAGEXECUTE', 'ROUTING', '{1}', '|>',
         'AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes(), '|>',
         'AI.SCRIPTEXECUTE',  script_name,
         'INPUTS', 1, image_key,
@@ -221,3 +225,14 @@ def test_dag_crossslot_violation_errors(env):
             'OUTPUTS', 1, 'resultTensor:{1}',
         )
         check_error_message(env, con, "CROSSSLOT Keys in request don't hash to the same slot", *command)
+
+        command = (
+            'AI.DAGEXECUTE', 'LOAD', '1', 'referenceTensor:{1}',
+            'PERSIST', '1', 'resultTensor:{1}', '|>',
+            'ROUTING', 'model_key{2}',
+            'AI.TENSORSET', 'transactionTensor:{1}', 'FLOAT', 1, 30, '|>',
+            'AI.MODELEXECUTE', 'model_key{2}',
+            'INPUTS', 1, 'transactionTensor:{1}',
+            'OUTPUTS', 1, 'resultTensor:{1}',
+        )
+        check_error_message(env, con, "CROSSSLOT Keys in request don't hash to the same slot", *command)
diff --git a/tests/flow/tests_deprecated_commands.py b/tests/flow/tests_deprecated_commands.py
index 91a5c154f..a35ba9b76 100644
--- a/tests/flow/tests_deprecated_commands.py
+++ b/tests/flow/tests_deprecated_commands.py
@@ -213,14 +213,43 @@ def test_modelset_modelrun_onnx(env):
     env.assertEqual(argmax, 1)
 
 
-def test_pytorch_scriptrun(env):
+def test_pytorch_scriptset(env):
     if not TEST_PT:
         env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
         return
 
     con = env.getConnection()
+
+    check_error(env, con, 'AI.SCRIPTSET', 'ket{1}', DEVICE, 'SOURCE', 'return 1')
+
+    check_error(env, con, 'AI.SCRIPTSET', 'nope')
+
+    check_error(env, con, 'AI.SCRIPTSET', 'nope', 'SOURCE')
+
+    check_error(env, con, 'AI.SCRIPTSET', 'more', DEVICE)
+    
+    check_error(env, con, 'AI.SCRIPTSET', 'ket{1}', DEVICE, 'TAG', 'asdf')
+    
     script = load_file_content('script.txt')
 
+    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'TAG', 'asdf', 'SOURCE', script)
+    env.assertEqual(ret, b'OK')
+
+    ensureSlaveSynced(con, env)
+
+def test_pytorch_scriptrun(env):
+    if not TEST_PT:
+        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
+        return
+
+    con = env.getConnection()
+    script = load_file_content('old_script.txt')
+
     ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
@@ -269,7 +298,7 @@ def test_pytorch_scriptrun_variadic(env):
 
     con = env.getConnection()
 
-    script = load_file_content('script.txt')
+    script = load_file_content('old_script.txt')
 
     ret = con.execute_command('AI.SCRIPTSET', 'myscript{$}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
@@ -462,7 +491,7 @@ def test_dagrun_modelrun_multidevice_resnet_ensemble_alias(env):
     class_key_0 = 'output0:{1}'
     class_key_1 = 'output1:{1}'
 
-    model_pb, script, labels, img = load_resnet_test_data()
+    model_pb, script, labels, img = load_resnet_test_data_old()
 
     device_0 = 'CPU:1'
     device_1 = DEVICE
diff --git a/tests/flow/tests_gears_llapi.py b/tests/flow/tests_gears_llapi.py
index 4bd029ef9..7f4ecb6b3 100644
--- a/tests/flow/tests_gears_llapi.py
+++ b/tests/flow/tests_gears_llapi.py
@@ -184,7 +184,7 @@ async def ScriptRun_AsyncRunError(record):
         self.env.assertEqual(ret, b'OK')
 
         script = load_file_content("script.txt")
-        ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+        ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{1}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
         self.env.assertEqual(ret, b'OK')
         ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
         self.env.assertEqual(ret, b'OK')
@@ -209,7 +209,7 @@ def test_runtime_error(self):
         con = self.env.getConnection()
         ret = con.execute_command('rg.trigger', 'ScriptRun_AsyncRunError_test3')
         # This should raise an exception
-        self.env.assertTrue(str(ret[0]).startswith("b'attempted to get undefined function"))
+        self.env.assertTrue(str(ret[0]).startswith("b'Function does not exist:"))
 
 
 class TestDAGRunExecution:
@@ -304,7 +304,7 @@ async def DAGRun_addOpsFromString(record):
         self.env.assertEqual(ret, b'OK')
 
         script = load_file_content('script.txt')
-        ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+        ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{1}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
         self.env.assertEqual(ret, b'OK')
 
     def test_modelset_modelget_ops(self):
@@ -335,7 +335,7 @@ def test_scriptexecute_op_runtime_error(self):
         con = self.env.getConnection()
         ret = con.execute_command('rg.trigger', 'DAGRun_test4')
         # This should raise an exception
-        self.env.assertTrue(str(ret[0]).startswith("b'attempted to get undefined function"))
+        self.env.assertTrue(str(ret[0]).startswith("b'Function does not exist:"))
 
     def test_build_dag_from_string(self):
         con = self.env.getConnection()
diff --git a/tests/flow/tests_llapi.py b/tests/flow/tests_llapi.py
index c7d9333b0..4b19bb263 100644
--- a/tests/flow/tests_llapi.py
+++ b/tests/flow/tests_llapi.py
@@ -63,7 +63,7 @@ def test_script_run_async(env):
     with open(script_filename, 'rb') as f:
         script = f.read()
 
-    ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{1}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
@@ -95,7 +95,7 @@ def test_dag_build_and_run(env):
     script_filename = os.path.join(test_data_path, 'script.txt')
     with open(script_filename, 'rb') as f:
         script = f.read()
-    ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{1}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command("RAI_llapi.DAGrun")
@@ -141,9 +141,9 @@ def test_dagrun_multidevice_resnet(env):
                               'OUTPUTS', 1, outputvar,
                               'BLOB', model_pb)
     env.assertEqual(ret, b'OK')
-    ret = con.execute_command('AI.SCRIPTSET', script_name_0, device_0, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name_0, device_0, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
-    ret = con.execute_command('AI.SCRIPTSET', script_name_1, device_1, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name_1, device_1, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
     ret = con.execute_command('AI.TENSORSET', image_key, 'UINT8', img.shape[1], img.shape[0], 3, 'BLOB', img.tobytes())
     env.assertEqual(ret, b'OK')
diff --git a/tests/flow/tests_pytorch.py b/tests/flow/tests_pytorch.py
index d19347204..2adc60f6b 100644
--- a/tests/flow/tests_pytorch.py
+++ b/tests/flow/tests_pytorch.py
@@ -229,34 +229,6 @@ def test_pytorch_modelinfo(env):
     env.assertEqual(info_dict_0['errors'], 0)
 
 
-def test_pytorch_scriptset(env):
-    if not TEST_PT:
-        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
-        return
-
-    con = env.getConnection()
-
-    check_error(env, con, 'AI.SCRIPTSET', 'ket{1}', DEVICE, 'SOURCE', 'return 1')
-
-    check_error(env, con, 'AI.SCRIPTSET', 'nope')
-
-    check_error(env, con, 'AI.SCRIPTSET', 'nope', 'SOURCE')
-
-    check_error(env, con, 'AI.SCRIPTSET', 'more', DEVICE)
-
-    script = load_file_content('script.txt')
-
-    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'SOURCE', script)
-    env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'TAG', 'asdf', 'SOURCE', script)
-    env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-
 def test_pytorch_scriptdel(env):
     if not TEST_PT:
         env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
@@ -266,7 +238,7 @@ def test_pytorch_scriptdel(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
@@ -299,7 +271,7 @@ def test_pytorch_scriptexecute(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 'myscript{1}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{1}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
@@ -349,7 +321,7 @@ def test_pytorch_scriptexecute_list_input(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 'myscript{$}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'myscript{$}', DEVICE, 'TAG', 'version1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command('AI.TENSORSET', 'a{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
@@ -362,55 +334,7 @@ def test_pytorch_scriptexecute_list_input(env):
     ensureSlaveSynced(con, env)
 
     for _ in range( 0,100):
-        ret = con.execute_command('AI.SCRIPTEXECUTE', 'myscript{$}', 'bar_variadic', 'KEYS', 1, '{$}', 'INPUTS', 1, 'a{$}', 'LIST_INPUTS', 2, 'b1{$}', 'b2{$}', 'OUTPUTS', 1, 'c{$}')
-        env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-    info = con.execute_command('AI.INFO', 'myscript{$}')
-    info_dict_0 = info_to_dict(info)
-
-    env.assertEqual(info_dict_0['key'], 'myscript{$}')
-    env.assertEqual(info_dict_0['type'], 'SCRIPT')
-    env.assertEqual(info_dict_0['backend'], 'TORCH')
-    env.assertEqual(info_dict_0['tag'], 'version1')
-    env.assertTrue(info_dict_0['duration'] > 0)
-    env.assertEqual(info_dict_0['samples'], -1)
-    env.assertEqual(info_dict_0['calls'], 100)
-    env.assertEqual(info_dict_0['errors'], 0)
-
-    values = con.execute_command('AI.TENSORGET', 'c{$}', 'VALUES')
-    env.assertEqual(values, [b'4', b'6', b'4', b'6'])
-
-    ensureSlaveSynced(con, env)
-
-    if env.useSlaves:
-        con2 = env.getSlaveConnection()
-        values2 = con2.execute_command('AI.TENSORGET', 'c{$}', 'VALUES')
-        env.assertEqual(values2, values)
-
-
-def test_pytorch_scriptexecute_multiple_list_input(env):
-    if not TEST_PT:
-        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
-        return
-
-    con = env.getConnection()
-
-    script = load_file_content('script.txt')
-
-    ret = con.execute_command('AI.SCRIPTSET', 'myscript{$}', DEVICE, 'TAG', 'version1', 'SOURCE', script)
-    env.assertEqual(ret, b'OK')
-
-    ret = con.execute_command('AI.TENSORSET', 'a{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-    ret = con.execute_command('AI.TENSORSET', 'b{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-    for _ in range( 0,100):
-        ret = con.execute_command('AI.SCRIPTEXECUTE', 'myscript{$}', 'bar_two_lists', 'KEYS', 1, '{$}', 'LIST_INPUTS', 1, 'a{$}', 'LIST_INPUTS', 1, 'b{$}', 'OUTPUTS', 1, 'c{$}')
+        ret = con.execute_command('AI.SCRIPTEXECUTE', 'myscript{$}', 'bar_variadic', 'KEYS', 1, '{$}', 'INPUTS', 3, 'a{$}', 'b1{$}', 'b2{$}', 'OUTPUTS', 1, 'c{$}')
         env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
@@ -437,102 +361,6 @@ def test_pytorch_scriptexecute_multiple_list_input(env):
         values2 = con2.execute_command('AI.TENSORGET', 'c{$}', 'VALUES')
         env.assertEqual(values2, values)
 
-def test_pytorch_scriptexecute_errors(env):
-    if not TEST_PT:
-        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
-        return
-
-    con = env.getConnection()
-
-    script = load_file_content('script.txt')
-
-    ret = con.execute_command('AI.SCRIPTSET', 'ket{1}', DEVICE, 'TAG', 'asdf', 'SOURCE', script)
-    env.assertEqual(ret, b'OK')
-
-    ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-    ret = con.execute_command('AI.TENSORSET', 'b{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-    con.execute_command('DEL', 'EMPTY{1}')
-    # ERR no script at key from SCRIPTGET
-    check_error_message(env, con, "script key is empty", 'AI.SCRIPTGET', 'EMPTY{1}')
-
-    con.execute_command('SET', 'NOT_SCRIPT{1}', 'BAR')
-    # ERR wrong type from SCRIPTGET
-    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTGET', 'NOT_SCRIPT{1}')
-
-    con.execute_command('DEL', 'EMPTY{1}')
-    # ERR no script at key from SCRIPTEXECUTE
-    check_error_message(env, con, "script key is empty", 'AI.SCRIPTEXECUTE', 'EMPTY{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    con.execute_command('SET', 'NOT_SCRIPT{1}', 'BAR')
-    # ERR wrong type from SCRIPTEXECUTE
-    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'NOT_SCRIPT{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    con.execute_command('DEL', 'EMPTY{1}')
-    # ERR Input key is empty
-    check_error_message(env, con, "tensor key is empty or in a different shard", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'EMPTY{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    con.execute_command('SET', 'NOT_TENSOR{1}', 'BAR')
-    # ERR Input key not tensor
-    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'NOT_TENSOR{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'a{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 1, 'b{1}', 'OUTPUTS')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 'OUTPUTS')
-
-    check_error_message(env, con, "KEYS scope must be provided first for AI.SCRIPTEXECUTE command", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'INPUTS', 'OUTPUTS')
-
-    if env.isCluster():
-        # cross shard
-        check_error_message(env, con, "CROSSSLOT Keys in request don't hash to the same slot", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{2}', 'INPUTS', 2, 'a{1}', 'b{1}', 'OUTPUTS', 1, 'c{1}')
-
-        # key doesn't exist
-        check_error_message(env, con, "tensor key is empty or in a different shard", 'AI.SCRIPTEXECUTE', 'ket{1}', 'bar', 'KEYS', 1 , '{1}', 'INPUTS', 2, 'a{1}', 'b{2}', 'OUTPUTS', 1, 'c{1}')
-
-
-def test_pytorch_scriptexecute_variadic_errors(env):
-    if not TEST_PT:
-        env.debugPrint("skipping {} since TEST_PT=0".format(sys._getframe().f_code.co_name), force=True)
-        return
-
-    con = env.getConnection()
-
-    script = load_file_content('script.txt')
-
-    ret = con.execute_command('AI.SCRIPTSET', 'ket{$}', DEVICE, 'TAG', 'asdf', 'SOURCE', script)
-    env.assertEqual(ret, b'OK')
-
-    ret = con.execute_command('AI.TENSORSET', 'a{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-    ret = con.execute_command('AI.TENSORSET', 'b{$}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
-    env.assertEqual(ret, b'OK')
-
-    ensureSlaveSynced(con, env)
-
-    con.execute_command('DEL', 'EMPTY{$}')
-    # ERR Variadic input key is empty
-    check_error_message(env, con, "tensor key is empty or in a different shard", 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 1, 'a{$}', "LIST_INPUTS", 2, 'EMPTY{$}', 'b{$}', 'OUTPUTS', 1, 'c{$}')
-
-    con.execute_command('SET', 'NOT_TENSOR{$}', 'BAR')
-    # ERR Variadic input key not tensor
-    check_error_message(env, con, "WRONGTYPE Operation against a key holding the wrong kind of value", 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 1, 'a{$}', "LIST_INPUTS", 2, 'NOT_TENSOR{$}', 'b{$}', 'OUTPUTS', 1, 'c{$}')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 2, 'b{$}', '${$}', 'OUTPUTS', 1, 'c{$}')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 1, 'b{$}', 'LIST_INPUTS', 'OUTPUTS')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'INPUTS', 'LIST_INPUTS', 'OUTPUTS')
-
-    check_error(env, con, 'AI.SCRIPTEXECUTE', 'ket{$}', 'bar_variadic', 'KEYS', 1 , '{$}', 'LIST_INPUTS', 1, 'a{$}', 'LIST_INPUTS', 1, 'b{$}' 'OUTPUTS')
-
 
 def test_pytorch_scriptinfo(env):
     if not TEST_PT:
@@ -546,7 +374,7 @@ def test_pytorch_scriptinfo(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 'ket_script{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket_script{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
@@ -599,7 +427,7 @@ def test_pytorch_scriptexecute_disconnect(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 'ket_script{1}', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 'ket_script{1}', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ret = con.execute_command('AI.TENSORSET', 'a{1}', 'FLOAT', 2, 2, 'VALUES', 2, 3, 2, 3)
@@ -661,10 +489,10 @@ def test_pytorch_modelscan_scriptscan(env):
 
     script = load_file_content('script.txt')
 
-    ret = con.execute_command('AI.SCRIPTSET', 's1', DEVICE, 'TAG', 's:v1', 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 's1', DEVICE, 'TAG', 's:v1', 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
-    ret = con.execute_command('AI.SCRIPTSET', 's2', DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', 's2', DEVICE, 'ENTRY_POINTS', 2, 'bar', 'bar_variadic', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     ensureSlaveSynced(con, env)
diff --git a/tests/flow/tests_tensorflow.py b/tests/flow/tests_tensorflow.py
index 592f21cfa..ca35701c7 100644
--- a/tests/flow/tests_tensorflow.py
+++ b/tests/flow/tests_tensorflow.py
@@ -654,7 +654,7 @@ def test_tensorflow_modelexecute_script_execute_resnet(env):
                               'BLOB', model_pb)
     env.assertEqual(ret, b'OK')
 
-    ret = con.execute_command('AI.SCRIPTSET', script_name, DEVICE, 'SOURCE', script)
+    ret = con.execute_command('AI.SCRIPTSTORE', script_name, DEVICE, 'ENTRY_POINTS', 4, 'pre_process_3ch', 'pre_process_4ch', 'post_process', 'ensemble', 'SOURCE', script)
     env.assertEqual(ret, b'OK')
 
     image_key = 'image1{1}'