Multi-project deployment

Only available on the Enterprise planThis feature is only available on the Enterprise plan. Review our plans and pricing or sign up for our free expert-led trial today.

Multi-project deployment enables you to bundle and run multiple Edge Impulse projects and impulses within a single deployment. This unlocks more advanced on-device pipelines, such as model cascades or running multiple independent models on the same MCU or Linux device — all using the standard Edge Impulse SDK. Key benefits:

Multiple impulses in one SDK build
Mix and match projects
- Different projects
- Different impulses
- Quantized and non-quantized models
- Object detection and non–object detection models together
No additional RAM or flash overhead when deploying only a single impulse
Works across all Edge Impulse supported development platforms

Some examples:

Model cascades:
- An object detection model to locate text
- Followed by an OCR or classification model on the detected regions
Multiple independent models on one device:
- Running several sensor-based models side-by-side on a single MCU
- Supporting different modalities or use cases simultaneously

Multi-project deployment

Multi-project deployment is enabled at the organization level.

Go to Multi-project deployments in your organization
Add one or more entries, each specifying:
- Project ID
- Impulse ID
- Variant (e.g. quantized or non-quantized, int8 or float32)

For example, with the following tutorial projects added to your organization:

Copy and paste the following example configuration (with projectIds changed to the IDs for projects in your organization):

[
    { "projectId": 14225, "impulseId": 2, "variant": "int8" },
    { "projectId": 14227, "impulseId": 1, "variant": "int8" },
    { "projectId": 25483, "impulseId": 1, "variant": "float32" }
]

Multi-project deployment with impulses configuration

Inference runtime

After defining your projects and impulses, choose your inference runtime:

EON Compiler
EON Compiler (RAM Optimized)
TensorFlow Lite

Deployment build configuration and runtime selection

After building, Edge Impulse generates a ZIP file, similar to a standard C++ deployment. You can load previous multi-project deployment configurations into the ‘Impulses’ field, by selecting the button to the right of the Job ID:

Load previous multi-project deployment configurations

Deployment package structure

The generated .tar.gz looks like a normal C++ deployment, with one key difference: it now contains multiple models, one per configured impulse.

Example multi-project deployment structure

Each deployed model has:

Its own model file
Its corresponding model parameters

Example multi-project deployment structure for 3 deployed models

New orchestration entry point

Multi-project deployments ship with an updated main.cpp example file. This file contains all orchestration logic required to run multiple deployed impulses in your application.

Working with multiple impulses in code

Show example of a deployed `main.cpp` with 3 different impulses

/*
* Copyright (c) 2025 EdgeImpulse Inc.
*
* Generated by Edge Impulse and licensed under the applicable Edge Impulse
* Terms of Service. Community and Professional Terms of Service
* (https://edgeimpulse.com/legal/terms-of-service) or Enterprise Terms of
* Service (https://edgeimpulse.com/legal/enterprise-terms-of-service),
* according to your product plan subscription (the “License”).
*
* This software, documentation and other associated files (collectively referred
* to as the “Software”) is a single SDK variation generated by the Edge Impulse
* platform and requires an active paid Edge Impulse subscription to use this
* Software for any purpose.
*
* You may NOT use this Software unless you have an active Edge Impulse subscription
* that meets the eligibility requirements for the applicable License, subject to
* your full and continued compliance with the terms and conditions of the License,
* including without limitation any usage restrictions under the applicable License.
*
* If you do not have an active Edge Impulse product plan subscription, or if use
* of this Software exceeds the usage limitations of your Edge Impulse product plan
* subscription, you are not permitted to use this Software and must immediately
* delete and erase all copies of this Software within your control or possession.
* Edge Impulse reserves all rights and remedies available to enforce its rights.
*
* Unless required by applicable law or agreed to in writing, the Software is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing
* permissions, disclaimers and limitations under the License.
*/

#include <stdio.h>
#include "edge-impulse-sdk/classifier/ei_run_classifier.h"

// Raw features copied from test sample
static const float features_impulse_14225_2[] = {
    // Copy raw features here (e.g. from the 'Live classification' page) for project 14225, impulse 2
    // https://studio.edgeimpulse.com/studio/14225/impulse/2/classification
};

static const float features_impulse_14227_1[] = {
    // Copy raw features here (e.g. from the 'Live classification' page) for project 14227, impulse 1
    // https://studio.edgeimpulse.com/studio/14227/impulse/1/classification
};

static const float features_impulse_25483_1[] = {
    // Copy raw features here (e.g. from the 'Live classification' page) for project 25483, impulse 1
    // https://studio.edgeimpulse.com/studio/25483/impulse/1/classification
};

int main(int argc, char **argv) {

    // project 14225, impulse 2
    {
        ei_printf("Impulse #1 (project 14225, impulse 2):\n");

        signal_t signal;            // Wrapper for raw input buffer
        ei_impulse_result_t result; // Used to store inference output
        EI_IMPULSE_ERROR res;       // Return code from inference

        const ei_impulse_t& impulse = impulse_14225_2;
        ei_impulse_handle_t& impulse_handle = impulse_handle_14225_2;

        run_classifier_init(&impulse_handle);

        // Calculate the length of the buffer
        size_t buf_len = sizeof(features_impulse_14225_2) / sizeof(features_impulse_14225_2[0]);

        // Make sure that the length of the buffer matches expected input length
        if (buf_len != impulse.dsp_input_frame_size) {
            ei_printf("ERROR: The size of the input buffer is not correct.\n");
            ei_printf("Expected %d items, but got %d\n",
                    impulse.dsp_input_frame_size,
                    (int)buf_len);
            return 1;
        }

        int err = numpy::signal_from_buffer(features_impulse_14225_2, impulse.dsp_input_frame_size, &signal);
        if (err != 0) {
            ei_printf("signal_from_buffer failed (%d)\n", err);
            return 1;
        }

        // Perform DSP pre-processing and inference
        res = run_classifier(&impulse_handle, &signal, &result, false);
        if (res != EI_IMPULSE_OK) {
            ei_printf("run_classifier returned: %d\n", res);
            return 1;
        }

        // See how to modify this in edge-impulse-sdk/classifier/ei_print_results.h
        ei_print_results(&impulse_handle, &result);
        ei_printf("\n");

        run_classifier_deinit(&impulse_handle);
    }


    // project 14227, impulse 1
    {
        ei_printf("Impulse #2 (project 14227, impulse 1):\n");

        signal_t signal;            // Wrapper for raw input buffer
        ei_impulse_result_t result; // Used to store inference output
        EI_IMPULSE_ERROR res;       // Return code from inference

        const ei_impulse_t& impulse = impulse_14227_1;
        ei_impulse_handle_t& impulse_handle = impulse_handle_14227_1;

        run_classifier_init(&impulse_handle);

        // Calculate the length of the buffer
        size_t buf_len = sizeof(features_impulse_14227_1) / sizeof(features_impulse_14227_1[0]);

        // Make sure that the length of the buffer matches expected input length
        if (buf_len != impulse.dsp_input_frame_size) {
            ei_printf("ERROR: The size of the input buffer is not correct.\n");
            ei_printf("Expected %d items, but got %d\n",
                    impulse.dsp_input_frame_size,
                    (int)buf_len);
            return 1;
        }

        int err = numpy::signal_from_buffer(features_impulse_14227_1, impulse.dsp_input_frame_size, &signal);
        if (err != 0) {
            ei_printf("signal_from_buffer failed (%d)\n", err);
            return 1;
        }

        // Perform DSP pre-processing and inference
        res = run_classifier(&impulse_handle, &signal, &result, false);
        if (res != EI_IMPULSE_OK) {
            ei_printf("run_classifier returned: %d\n", res);
            return 1;
        }

        // See how to modify this in edge-impulse-sdk/classifier/ei_print_results.h
        ei_print_results(&impulse_handle, &result);
        ei_printf("\n");

        run_classifier_deinit(&impulse_handle);
    }


    // project 25483, impulse 1
    {
        ei_printf("Impulse #3 (project 25483, impulse 1):\n");

        signal_t signal;            // Wrapper for raw input buffer
        ei_impulse_result_t result; // Used to store inference output
        EI_IMPULSE_ERROR res;       // Return code from inference

        const ei_impulse_t& impulse = impulse_25483_1;
        ei_impulse_handle_t& impulse_handle = impulse_handle_25483_1;

        run_classifier_init(&impulse_handle);

        // Calculate the length of the buffer
        size_t buf_len = sizeof(features_impulse_25483_1) / sizeof(features_impulse_25483_1[0]);

        // Make sure that the length of the buffer matches expected input length
        if (buf_len != impulse.dsp_input_frame_size) {
            ei_printf("ERROR: The size of the input buffer is not correct.\n");
            ei_printf("Expected %d items, but got %d\n",
                    impulse.dsp_input_frame_size,
                    (int)buf_len);
            return 1;
        }

        int err = numpy::signal_from_buffer(features_impulse_25483_1, impulse.dsp_input_frame_size, &signal);
        if (err != 0) {
            ei_printf("signal_from_buffer failed (%d)\n", err);
            return 1;
        }

        // Perform DSP pre-processing and inference
        res = run_classifier(&impulse_handle, &signal, &result, false);
        if (res != EI_IMPULSE_OK) {
            ei_printf("run_classifier returned: %d\n", res);
            return 1;
        }

        // See how to modify this in edge-impulse-sdk/classifier/ei_print_results.h
        ei_print_results(&impulse_handle, &result);
        ei_printf("\n");

        run_classifier_deinit(&impulse_handle);
    }

}

Features arrays

Instead of a single features[] array, you now have one features array per impulse. For example, with three impulses:

Impulse 1: Quantized (int8) classification / anomaly detection
Impulse 2: Free-form impulse
Impulse 3: Object detection (e.g. FOMO, float32)

Each impulse:

Has its own input features
Produces its own output tensors

Running inference

At runtime, inference is straightforward:

Initialize each impulse
Populate the corresponding features array
Call run_classifier() once per impulse, using the appropriate impulse handle
Read and interpret the results per model

All remaining logic is standard Edge Impulse inference orchestration.

Example output

In a single application run, you might see:

Impulse 1
- Classification result: wave ≈ 0.1
- Anomaly score: ≈ 1.1
Impulse 2
- Free-form outputs
- Multiple output tensors
Impulse 3
- Object detection result
- Single detected object class (e.g. person, or object of interest)

Troubleshooting

No common issues have been identified thus far. If you encounter an issue, please reach out on the forum or, if you are on the Enterprise plan, through your support channels.

OVERVIEW

PROJECTS

ORGANIZATIONS