Deployment

MIND targets cloud, edge, and on-premise deployment. Serving infrastructure, auto-scaling integration, and monitoring ship with the commercial mind-runtime.

Key takeaway

The mind deployment CLI on this page is the commercial mind-runtime surface, not the open-source compiler driver mindc.

Model serving infrastructure

Commercial

Native + ONNX export with quantization (FP32→INT4), HTTP/gRPC inference server with dynamic batching, Prometheus metrics, and Kubernetes health checks ship with the commercial mind-runtime.

Cloud deploy, canary rollouts, model versioning

Planned

The mind deployment CLI shown throughout this page is that commercial surface, and several of its workflows (cloud deploy, canary rollouts, model versioning) are still roadmap. See the Roadmap for details.

Open toolchain: mindc

Shipped

The mind CLI is not the open-source compiler driver: the open toolchain ships mindc, which compiles deterministic native binaries and emits/verifies evidence chains. See Using Core v1 for the commands that work against a public build today.

Deployment Options

MIND supports multiple deployment targets:

Target	Use Case	Features
Container	Kubernetes, Docker	Auto-scaling, health checks, rolling updates
Serverless	AWS Lambda, Cloud Run	Pay-per-request, automatic scaling
Edge	IoT, mobile, embedded	Optimized binary, low latency
Bare Metal	On-premise, HPC	Maximum performance, custom hardware

Quick Start

Deploy a trained model with a single command:

# Build optimized inference binary
mind build --release model.mind -o model.bin

# Deploy to local serving endpoint
mind serve model.bin --port 8080

# Or deploy to cloud
mind deploy model.bin --target aws --region us-east-1

Container Deployment

Generate production-ready Docker images with the MIND CLI:

# Generate Dockerfile and build image
mind container build --image my-model:v1.0 model.mind

# Push to registry
docker push my-model:v1.0

# Deploy to Kubernetes
mind deploy model.mind \
    --target kubernetes \
    --replicas 3 \
    --cpu 2 \
    --memory 4Gi \
    --gpu 1

Kubernetes Manifest

MIND generates Kubernetes manifests with best practices:

# Generated by: mind deploy --target kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-model
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-model
  template:
    spec:
      containers:
      - name: inference
        image: my-model:v1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "2"
            memory: "4Gi"
            nvidia.com/gpu: "1"
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
        livenessProbe:
          httpGet:
            path: /health
            port: 8080

Model Serving

MIND's built-in serving infrastructure provides REST and gRPC endpoints:

use mind::serve::{Server, Endpoint};

// Define inference endpoint
@endpoint("/predict")
fn predict(input: Tensor<f32, [1, 784]>) -> Tensor<f32, [1, 10]> {
    model.forward(input)
}

// Start server with auto-batching
fn main() {
    Server::new()
        .model(model)
        .batch_size(32)
        .batch_timeout_ms(10)
        .port(8080)
        .serve();
}

API Endpoints

The serving runtime exposes these endpoints:

Endpoint	Method	Description
/predict	POST	Run inference on input data
/health	GET	Health check for load balancers
/metrics	GET	Prometheus metrics
/info	GET	Model metadata and version

Pure-MIND Protocol & Crypto Primitives

The networking layer is building toward a fully self-hosted stack. MIND now includes a library of crypto and protocol primitives written in pure MIND and verified against RFC and NIST known-answer tests: AES-128-GCM, SHA-256, HKDF, X25519, X.509 parsing and signature verification, SHA-3/SHAKE (Keccak), RSA-PSS, ECDSA-P256, ML-KEM-768 (FIPS 203 post-quantum), the TLS 1.3 key schedule, record layer, and handshake transcript (replay-verified against RFC 8448), HPACK (RFC 7541), and HTTP/2 framing (RFC 9113).

Honest scope

This is a verified primitive library, not yet a working TLS client or server: there is no socket-driven handshake state machine or certificate-chain path validation yet, and HPACK is decode-only. The primitives are correctness-first, not speed-optimized.

Edge Deployment

Deploy optimized models to edge devices with minimal runtime:

# Build for ARM64 edge device
mind build --target aarch64-unknown-linux-gnu \
    --optimize size \
    --quantize int8 \
    model.mind -o model-edge.bin

# Build for WebAssembly (browser)
mind build --target wasm32 \
    --optimize size \
    model.mind -o model.wasm

Optimization Options

Quantization

INT8/INT4 inference for reduced memory and faster execution.

Pruning

Remove redundant weights for smaller models.

Fusion

Combine operators for fewer kernel launches.

Static shapes

Compile with fixed input shapes for optimized code paths.

A/B Testing & Canary Deployments

MIND supports gradual rollouts and traffic splitting:

# Deploy new version with 10% traffic
mind deploy model-v2.mind \
    --canary \
    --traffic-percent 10 \
    --monitor latency,accuracy

# Promote to 100% after validation
mind deploy promote model-v2

# Rollback if issues detected
mind deploy rollback

Monitoring & Observability

Built-in monitoring with OpenTelemetry integration:

use mind::serve::{Server, Metrics};

Server::new()
    .model(model)
    .metrics(Metrics::new()
        .histogram("latency_ms")
        .counter("requests_total")
        .gauge("batch_size")
        .enable_tracing())
    .otlp_endpoint("http://collector:4317")
    .serve();

Available Metrics

Inference latency

p50, p95, p99 latency histograms.

Throughput

Requests per second, batch utilization.

Resource usage

GPU memory, CPU utilization.

Model drift

Input/output distribution changes.

Error rates

Failed predictions, timeouts.

Model Versioning

Track and manage model versions with built-in versioning:

# Tag a model version
mind model tag model.mind v1.2.0 --message "Improved accuracy"

# List versions
mind model versions

# Deploy specific version
mind deploy model@v1.2.0

# Compare versions
mind model diff v1.1.0 v1.2.0

Best Practices

Always use versioned model artifacts in production
Enable health checks and readiness probes for container deployments
Use auto-batching to maximize throughput under load
Set resource limits to prevent OOM issues
Monitor model drift and retrain when accuracy degrades
Use canary deployments for risky changes

Learn More

See Distributed Execution for multi-node deployment and the Roadmap for upcoming deployment features.