The world's first confidential compute inference engine, built for the agentic era. Lifeboat handles the repeated model calls, tool chaining, and long-running context that overwhelm traditional inference engines — while protecting data even while it's being processed, not just at rest or in transit. Run more concurrent agents on existing GPUs while maintaining full model quality and keeping data inside your perimeter.
Lifeboat runs seamlessly across the AI infrastructure spectrum—from NVIDIA DGX Spark and RTX PRO systems to enterprise GPUs including H100, H200, B300, and beyond, with full support for AMD ROCm.
Lifeboat is the world's first confidential compute inference engine — an LLM inference engine purpose-built for the concurrency and long-running context that agentic AI workloads demand, with confidential compute built directly into the engine to protect data in use. It runs on infrastructure enterprises already own, delivering 2-6x more concurrent capacity on the same GPU hardware while eliminating per-token cloud costs and keeping data inside the enterprise perimeter.
Native app, no Docker required. Or run the container on a GPU server.
A single chatbot question is one model call. A single agent task can be dozens — planning, tool calls, MCP roundtrips, retries, and reflection, all riding on a conversation that keeps growing.
Lifeboat is purpose-built for the way agents actually consume inference. Instead of treating every request like an isolated chatbot prompt, it manages memory, scheduling, and model precision for fleets of long-running, tool-using agents on shared hardware. Four things make that possible:
The payoff: 2x or more concurrent agent sessions on the same GPU, full model quality intact, and performance that holds steady as load climbs.
Lifeboat isn't just a faster engine. It's a managed control plane for inference at scale, with a built-in cluster manager that orchestrates Lifeboat across nodes — and manages your other inference engines alongside it. One place to deploy, route, monitor, and govern the GPUs serving your agents.
Your data stays where it belongs — inside your perimeter, governed by your policies, and never exposed to shared AI services.
Use, tune, and control the models that power your workflows. Own what you build instead of depending on opaque external systems.
Run inference on infrastructure you control — on-premise or cloud VPC — and edge deployments.
Benchmarks used a Qwen 30B A3B model and long-context workloads that simulate real enterprise agents processing large documents in parallel.
Lifeboat ships a native ROCm build alongside the CUDA one — the same control plane, the same OpenAI-compatible API, the same dashboard, validated end-to-end on AMD Instinct hardware. None of the optimization work is CUDA-specific, so it carries across unchanged.
Performance is only part of the challenge. Production AI requires governance, orchestration, security, and operational controls that raw inference engines don't provide. Lifeboat combines high-performance inference with the infrastructure required to run AI at scale.
Lifeboat runs three ways: as a native desktop app on macOS or Linux, or as a Docker container on a GPU server or a machine with no GPU at all. There is one Docker image per target — NVIDIA hosts pull iterateai/lifeboat:latest, AMD hosts pull iterateai/lifeboat:latest-rocm, and a host with no GPU pulls iterateai/lifeboat:lite. The installer detects which you have, checks every requirement and fixes anything missing, but here's the list for reference:
Lifeboat is the world's first confidential compute inference engine — an
enterprise-grade, self-hosted LLM inference platform that combines high-performance
model serving with a complete operational control plane. Confidential compute is
built directly into the engine, protecting data even while it's being processed.
It delivers roughly 2x concurrent user capacity per GPU without quantizing model
weights, while providing a web dashboard, role-based access control, audit logging,
security capsules for sandboxed session isolation, and multi-node cluster
orchestration—all behind an OpenAI-compatible API.
Lifeboat uses patent-pending optimizations including FP8 KV-cache compression, TurboQuant vector quantization, adaptive memory management, and fairness-aware scheduling to roughly double concurrent-session capacity on the same GPU hardware. These optimizations compress the cache while keeping model weights at full BF16 precision, preserving output quality.
Deploys as a hardened Docker container, a Helm chart on Kubernetes, or a native desktop app for macOS and Linux. Supports air-gapped, on-premise or cloud VPC environments. All state is managed via an embedded SQLite database, enabling deployment in restricted and regulated environments.
Yes. Lifeboat exposes an OpenAI-compatible API, making it a drop-in replacement for existing OpenAI client code. It also supports Anthropic and Ollama protocol compatibility, working seamlessly with LangChain, LlamaIndex, LiteLLM, and other standard LLM client libraries.
Lifeboat provides four-tier role-based access control (RBAC), API key management
with lifecycle controls, encryption at rest for secrets, comprehensive audit
logging with CSV export, container hardening (non-root user, dropped capabilities,
read-only filesystem), and optional TLS/HTTPS support. Every session runs inside a
security capsule for secure guardrailing and sandboxed execution, and confidential
compute protects data while it's actively being processed. It's designed for
self-hosted deployment — on-premise or cloud VPC — to keep private AI data within
your environment.
Lifeboat supports 168+ model architectures. New architectures are absorbed automatically with a single upgrade command, ensuring broad and current model support.
Yes. Lifeboat includes multi-node cluster orchestration with a control-plane node and node agents on each GPU host. It features token-aware weighted load balancing, capacity gating, and intelligent routing across cluster nodes, all managed through a unified gateway and web dashboard.
Lifeboat provides a comprehensive web dashboard covering real-time metrics, server lifecycle management, a searchable model catalog with capability probing, cluster orchestration, user and API key management, configuration presets, and a full audit trail—turning inference operations into a point-and-click experience with no terminal required.
Yes — Lifeboat ships a native ROCm build for AMD Instinct alongside the CUDA one. It is the same control plane, dashboard and OpenAI-compatible API, validated end-to-end on an Instinct MI210. Pull iterateai/lifeboat:latest-rocm instead of :latest — a container image is selected by CPU architecture rather than GPU vendor, so one tag cannot serve both. AMD hosts need no container toolkit; the GPU is passed through as the /dev/kfd and /dev/dri device nodes. Kernels are compiled per CDNA generation, so there is one image for MI210/MI250, one for MI300X/MI325X and one for MI350X/MI355X. The only feature that is NVIDIA-only is GPU confidential computing, which has no AMD equivalent; on AMD it reports as unsupported and inference runs normally.