Scaleout Edge / Platform

Operate AI across
devices and sites.

Deploy and manage models, coordinate fleet learning, and build continuous improvement into your deployment. Scaleout Edge provides the shared foundation for your applications and workflows.

Model operations as the foundation.
Learning within and across deployments.
Your applications & workflows
Custom applicationsModels & training workflowsOperational integrations
SDKs & integration interfaces

Scaleout Edge

Shared software foundation
Core / Model-agnostic

Operate models. Coordinate fleet learning.

Registry · Orchestration · Federated learning · Observability & lineage · Signed updates

Loop / Continuous improvement

Build a local learning loop.

Observation selection · Retraining · Evaluation · Human-approved updates

Packaged improvement workflow for computer vision; custom workflows can be built on Core.
Embeddable runtimes & device interfaces
Your deployment environment
Devices & local computeDistributed datasetsSites & operating conditions
Integrate Scaleout Edge with your existing models, tools, and applications through SDKs, APIs, and embeddable runtimes.
Platform capabilities

Operate models.
Build improvement into the system.

Model-agnostic operations and federated learning form the foundation. Add your own improvement workflow, or use the packaged computer vision loop.

ModelOps

Manage the model lifecycle.

Stage model versions and deploy them to selected devices through controlled rollouts. Keep a traceable record of what ran where and when.

Mechanisms
  • Model registry
  • Versioned staging
  • Signed updates
  • Targeted rollout
Federated learning

Train across local datasets.

Combine local model contributions through hierarchical aggregation. Customise participation and training logic through Server Functions.

Mechanisms
  • FedAvg
  • FedOpt
  • Custom aggregation
  • Server Functions
Resilient operations

Keep operating through disruption.

Set participation thresholds and round timeouts. Keep inference local and synchronise work when connections return.

Mechanisms
  • Round policies
  • Local execution
  • Buffering & backfill
Local improvement

Build a local learning loop.

Build a workflow from operational data through retraining, evaluation, and approval. Use the platform’s operations and training capabilities with your own application-specific processes.

Mechanisms
  • Retraining workflows
  • Candidate evaluation
  • Human approval
Across the platform

Observability & lineage help monitor model and device behaviour and trace model versions through training and deployment. SDKs & APIs connect these capabilities to your applications and workflows.

Model operations in practice

Know what runs where.
Control what changes.

Manage the model lifecycle across deployments, from candidate evaluation to approved releases and a traceable record of what runs where.

Model registry

Versioned models

v1.2
Approved
v1.3
Approved
v1.4
Candidate / In evaluation
Deployment group A

Running v1.2

DeviceDeviceDevice
Deployment group B

Running v1.3

DeviceDeviceDevice
Illustrative version assignments. Approved releases can be deployed to selected devices.
Deployment control

Manage model versions

Keep evaluated candidates and approved releases in a shared model registry.

Deploy with control

Distribute approved versions to selected devices when connectivity allows. Local inference continues through connection loss.

Maintain operational visibility

Track deployment records, reported device status, and metrics, with lineage back to training.

Distributed training architecture

Shared coordination.
Local training.

Federated training runs across clients with local data. Combiners coordinate groups of clients and aggregate their updates; shared platform services manage the training session and resulting model versions.

Platform services

Control plane & Reducer

Manage sessions and model versions. Combine contributions across combiners.

Combiner

Coordinate clients and aggregate updates.

ClientCompute packageLocal data
ClientCompute packageLocal data
ClientCompute packageLocal data
Combiner

Coordinate clients and aggregate updates.

ClientCompute packageLocal data
ClientCompute packageLocal data
ClientCompute packageLocal data
Deployment considerations

Place services to fit your deployment.

Host platform services on your infrastructure, with combiners placed centrally or closer to clients.

Connect from the client.

Clients initiate outbound connections. Training policies accommodate timeouts and partial participation; training data remains at each client.

Trace training through to deployment.

Connect training sessions, participating clients, model versions, and deployment records. Use metrics and telemetry to understand what ran where.

Technical fit

Built around your models
and infrastructure.

Keep your development tools and choose the deployment infrastructure. SDKs, APIs, and extension points connect the platform to your models and operations.

Your AI environment

Your models & workflows

Existing models, training tools, and application logic

SDKs & APIs

Scaleout Edge

Server infrastructure

Platform services

Registry, orchestration, aggregation, and records

Devices & local compute

Client SDKs & runtimes

Local execution, model updates, and telemetry integration

Runtime & device interfaces
Your operational environment

Your devices & systems

Compute, sensor feeds, and operator tools

Integration considerations

Keep your models and tools

Connect existing training workflows and application models through SDKs and APIs.

Choose where it runs

Deploy within your infrastructure, with compute placed centrally or closer to devices.

Connect to operational systems

Integrate sensor feeds and operator tools, with engineering support scoped to the deployment.

Build & integrate

Client SDKs
Python · Apache 2.0
C++ and Kotlin / Android: Technology Preview
Licensing
Client SDKs are Apache 2.0; platform server components are commercially licensed.
ML frameworks
PyTorch · TensorFlow / Keras · TFLite · scikit-learn · Hugging Face Transformers
Compute Packages
Package training logic and dependencies; distribute through the platform or stage locally.
Server Functions
Custom client selection, per-round settings, and aggregation.
Automation
Python APIClient and REST API for sessions, model operations, metrics, and records.
Model provenance
Trace model versions to training packages, participating clients, sessions, and aggregation events through the API.

Deploy & operate

Deployment
Docker Compose for evaluation and pilots; Kubernetes / Helm for production.
Hosting
Self-host on-premises or in cloud infrastructure, without a third-party SaaS dependency. Discuss sovereign, air-gapped, restricted-registry, and Scaleout-hosted configurations for your deployment.
Release lifecycle
Versioned deployment artefacts support controlled maintenance. Confirm release documentation, compatibility, and upgrade procedures for your deployment.
Edge targets
Jetson · x86 compute · Raspberry Pi, according to workload and runtime requirements.
Training rounds
Synchronous by default; configurable timeouts and minimum participation. Custom asynchronous coordination through Server Functions.
Telemetry
Dashboards and REST APIs; OpenTelemetry export for enterprise deployments.

Security & access

Transport
TLS-protected communications and authenticated clients.
Device connections
Outbound connections; no inbound device ports required.
Model integrity
Cryptographically signed model distribution.
Enterprise identity
Role-based access control and identity integration through OIDC / LDAP.
Enterprise encryption
Envelope encryption with KMS integration.
Software supply chain
Review software bills of materials (SBOMs), dependency scanning, and vulnerability reporting requirements as part of the deployment assessment.
Training-data privacy
Implement additional model-update privacy protections, such as differential privacy, through custom aggregation.
Ways to use Scaleout Edge

Build your own application.
Or start with a packaged offering.

Start with the infrastructure, or with the models, tools, and integrations for your operational task.

Build with Scaleout Core

Bring your models and workflows. Use Core for model operations and federated learning across your devices and sites, with engineering support and knowledge transfer scoped to help your team integrate and operate the platform.

Discuss your architecture

Start with operational computer vision

Tactical CV Network combines Scaleout Edge with computer vision models, operational tools, and deployment integrations. Run models on your devices and connect field observations to evaluated, human-approved updates.

Explore Tactical CV Network