Twelve focused products.
One platform.

Log in, get a governed Kubernetes workspace. No kubectl, no tickets.

On first SSO login every user gets an isolated namespace with quotas, default-deny networking, storage, and a web terminal — provisioned automatically, reconciled continuously. It is also the platform's front door: the token authority every TAIP app trusts, the SSH gateway into every workspace, and the taip CLI the cluster serves itself.

Jupyter or VS Code on a GPU in seconds. Idle environments shut themselves down.

Single-click Jupyter, Marimo, Streamlit, Gradio, and VS Code environments — GPU-ready, isolated per user behind a per-pod auth proxy, shareable with a colleague, and idle-shutdown by default.

A template is a shape. Your project fills it. Kubernetes runs the job.

Self-describing templates render straight into UI forms — or your project declares itself in a trainx.yaml and runs on a platform shape. Live quota checks, streaming logs, parsed progress, MLflow-tracked parameters and metrics, resumable runs, and declared outputs you can hand to the next step.

Your own Hugging Face Hub. Change one env var — every client just works.

A self-hosted, HF-compatible model and dataset registry: transformers, datasets, huggingface-cli, git-lfs, and the Xet protocol all work unchanged — plus a browsable Hub UI with model cards, a paging dataset viewer, file history, OIDC, audit, quotas, and pull-through caching of the public Hub.

OpenAI- and Anthropic-compatible inference on your GPUs — measured to the token.

A self-hosted Model-as-a-Service: an OpenAI- and Anthropic-compatible gateway that also serves embeddings, reranking, audio (TTS and ASR), and vision — with KServe deployment management, multi-deployment routing with circuit breakers, prefix-cache-aware pod routing for long-context agent traffic, and per-user, per-key, per-model cost attribution.

An OCI registry with real identity, runtime-mutable policy, and an air-gap story.

A curated fork of CNCF Zot: single binary, modern admin UI, OIDC SSO with passkeys, namespace members managed by role, CVE scanning with a policy you set per namespace, quotas, robot accounts for CI — deployable on Kubernetes, air-gapped, or bare metal.

Agents as a first-class Kubernetes primitive — versioned, sandboxed, fully traced.

Author a versioned Agent, then run it as Sessions — autonomous tasks or interactive chat — on Kubernetes. Per-session sandbox isolation with deny-by-default egress, built-in / MCP / custom tools, cross-session memory, cron schedules, always-on services, and a live event trace with token accounting — behind an OIDC SSO front door with per-user sessions. All reconciled from CRDs on agent.tensorstack.dev.

Ground your agents in your documents — scanned PDFs included, every answer cited to the page.

The knowledge layer for TAIP agents: ingest a document corpus — scanned PDFs included — and serve it back as hybrid, reranked, page-cited retrieval. Multiple isolated knowledge bases behind OIDC SSO and per-KB access control; embeddings and reranking on your own InferX, vectors in a pluggable vector DB. Agents call mcp__kb__search and cite the page instead of guessing.

Your Slurm scripts, unchanged — running on Kubernetes, with one login, one home, one quota.

A real, multi-tenant Slurm 25.11 cluster on Kubernetes. Researchers run their existing sbatch / srun / sacct workflows byte-for-byte unchanged — or never open a terminal at all and work from a browser desktop; the platform supplies one identity, one shared /home and /scratch, and one quota, and operators run Kubernetes instead of a separate HPC island.

Bare hosts to a working AI platform — even with the internet unplugged.

An air-gap-first platform installer: Kubernetes, eBPF networking, replicated storage, load balancing, identity with MFA, registry, GPU operators, and gang-admitted multi-node training — packed once on a build host, deployed anywhere, idempotently.