Skip to content
TAIP

TAIP — The AI Platform

Sovereign AI
infrastructure

The full AI lifecycle — develop, train, register, serve, operate — running on hardware you own, behind a boundary you control. Speaking the APIs you already use.

Explore the platform Why TAIP

on-prem · VPC · air-gapped — zero bytes leave

12
products, one platform
5
GPU vendors supported
15
model serving presets
2
languages — EN · 中文
100%
air-gap installable
0
bytes leave your perimeter

§ 01 — The argument

AI teams are offered two bad deals. TAIP is the third option.

Rent everything and lose control — or assemble everything and own the debt. We built the platform that should have existed: coherent like a cloud, yours like hardware.

Option one

Rent someone else's cloud

  • Your prompts, weights, and data live on infrastructure you don't control
  • Per-token pricing set by someone else, changed without asking you
  • Their roadmap, their deprecations, their region availability
  • Compliance becomes a negotiation instead of a property

Fast to start. Expensive to trust.

Option two

Stitch a dozen open-source tools

  • JupyterHub + a trainer + a registry + a gateway + a dashboard…
  • Identity, quotas, and audit glued together by your team, forever
  • Every upgrade is an integration project; every gap is your on-call
  • The platform team becomes the product team — unpaid

Free to download. You own the debt.

The third option

TAIP — one platform, your perimeter

  • The whole lifecycle — develop, train, register, serve, operate — on one stack
  • One identity, one token authority, one quota model, one audit trail across every product
  • Open standards at every seam: OCI, OpenAI/Anthropic APIs, OIDC, MCP, OTEL
  • Installs into your data center, your VPC, or a fully air-gapped site

Coherent like a cloud. Yours like hardware.

§ 02 — Platform tour

One lifecycle. Every stage covered.

Follow a model from the first notebook to governed production. At each stage: the TAIP product that carries it, what it does, and a real workflow from the shipping release — no proprietary SDKs, no client rewrites.

01 — Develop / 09

DevSpace

Available

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.

Key capabilities

  • Notebook, IDE, app — same plane Jupyter, Marimo, Streamlit, Gradio, VS Code Server out of the box.
  • Isolated by default Each environment runs as its own StatefulSet with an oauth2-proxy sidecar.
  • Idle shutdown that frees GPUs An activity sidecar polls the IDE — reading Jupyter's real kernel activity, not just liveness.
Explore DevSpace
real SSH, no kubeconfig 
# your laptop → a GPU environment, through the platform SSH gateway
$ ssh alice+env=jupyter@gateway.intra.example
(jupyter) $ nvidia-smi --query-gpu=name --format=csv,noheader
NVIDIA A100-SXM4-80GB
# idle for 2h → scaled to zero, PVC intact, GPU back in the pool▌

Native SSH UX — shell, scp, sftp, and port forwarding — authenticated by the key you registered once in ConsoleX. One gateway for every workspace, no kubectl anywhere.

Boot
Seconds
IDEs
Jupyter · VS Code · Marimo · Streamlit · Gradio
Idle
Auto stop or delete
Sharing
Per environment, by name

02 — Train / 09

TrainX

Available

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.

Key capabilities

  • Two ways in: appliances and shapes An appliance is a shape with a program — download a model, merge an adapter, run lm-eval — and its TrainXJobTemplate carries typed parameter metadata the web UI renders straight into a form.
  • Run, watch, and keep the record Live streaming logs with a viewer that handles 10k-line runs.
  • A run that survives its first OOM A template that promises a checkpoint contract gets automatic resume: a restart budget, one pod per attempt so the failed attempt's logs survive, and an attempt history that makes 'it OOM'd twice and is now on attempt 3' legible without reading pod history.
Explore TrainX
your project declares itself 
# trainx.yaml, beside your code — the platform reads it at submission
entrypoints:
  train:
    script: train.py
    outputs: [{ name: adapter, type: adapter, path: out/ }]
    checkpointing: { supported: true, dir: ckpt/ }

$ taip trainx run --entrypoint train    # submits the chain, needs first
sft-lora  ████████████░░░░░░░░  62/100  loss=0.8214   resumable▌

No SDK and no callback hooks: a print of TRAINX_PROGRESS: i/N still draws the bar, and a metrics file the job already writes is read at archive time. Logs, events, artifacts, and TensorBoard ride along.

Surface
Form from a template, or your trainx.yaml
Backed by
TrainXJob CRD · Kubernetes Job or JobSet
Observability
Logs · progress · events · TensorBoard · MLflow

03 — Register / 09

ModelSphere

Available

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.

Key capabilities

  • Wire-compatible with the Hub Wire-compatible with huggingface_hub — so transformers, datasets, diffusers, and huggingface-cli work by setting HF_ENDPOINT.
  • Real git underneath git clone, git lfs pull, and git lfs push work natively; objects beyond 5 GiB upload via Hugging Face's multipart transfer.
  • A browsable Hub, not just an API Beyond the wire protocol, ModelSphere ships a web UI: searchable browse with tag, pipeline, and library filters; model cards rendered with syntax highlighting and GitHub-style alerts; an in-browser file viewer and commit history; discussions and likes.
Explore ModelSphere
one env var, every client 
$ export HF_ENDPOINT=https://models.intra.example

# everything downstream just works — no client patches
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
# served from your registry; cached from upstream or fully air-gapped▌

Wire-compatible with the Hugging Face Hub API — including git clone and multi-gigabyte LFS transfers.

Protocol
HF Hub API · git · LFS · Xet
Modes
Registry · pull-through cache
Identity
OIDC · scoped tokens

04 — Serve / 09

InferX

Available

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.

Key capabilities

  • OpenAI- and Anthropic-compatible — and multimodal Drop-in /v1/chat/completions, /v1/embeddings, /v1/rerank, /v1/audio/speech and /v1/audio/transcriptions, plus /anthropic/v1/messages and KServe v2 /v2/models/:model/infer — all with streaming SSE.
  • Multi-vendor GPU and KServe-native Auto-detected NVIDIA, AMD, Intel, Huawei Ascend, and Cambricon.
  • Cost, latency, and errors per model Every request is OTEL-instrumented.
Explore InferX
change one URL, keep your code 
from openai import OpenAI
client = OpenAI(
    base_url="https://inferx.intra.example/api",  # ← the change
    api_key=os.environ["INFERX_API_KEY"],
)
# Anthropic SDKs and claude-code work the same way via /anthropic/v1
# every request lands in the dashboard: cost · P50/P95/P99 · errors▌

Drop-in for both OpenAI and Anthropic SDKs, streaming included — with per-key budgets, rate limits, and model allowlists.

Protocols
OpenAI · Anthropic · streaming SSE
Runtimes
vLLM · llama.cpp · any KServe runtime
Hardware
NVIDIA · AMD · Intel · Ascend · Cambricon
Routing
Prefix-cache-aware

05 — Ground / 09

GrokX

Available

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.

Key capabilities

  • Ingestion that reads scanned PDFs Walk a corpus and extract every page: born-digital text straight from the text layer, image-only scans via OCR.
  • Hybrid retrieval, reranked Sparse keyword vectors and dense embeddings are stored together in the vector DB and combined with rank fusion, then a cross-encoder reranker reorders the top results.
  • Page-level citations Every chunk keeps its source and page, so an agent can answer 'per page 12 of report.pdf' instead of producing an unverifiable claim.
Explore GrokX
a corpus becomes a tool your agents can call 
$ grokx push ./corpus --kb research   # upload + OCR scans + index, resumable
ingested 142 docs · 38 OCR'd · 1,907 pages → indexed 9,841 chunks
$ grokx serve                          # MCP server (streamable HTTP) on :8080
serving 6 knowledge bases
# an AgentX Agent calls the tool — hybrid + reranked, with a citation:
mcp__kb__search("Q3 revenue", kb="research") → "…revenue was $4.2M…"  [report.pdf p.12]▌

OCR and embedding run once at ingest, not per query. Sparse keyword and dense vectors are fused and reranked at search time, and every passage keeps its source and page so the answer can be cited.

Serves
Knowledge to agents
Retrieval
Hybrid + reranked
Citations
Page-level

06 — Automate / 09

AgentX

Preview

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.

Key capabilities

  • Versioned Agent definitions Author an Agent once — model, system prompt, tools, memory, sandbox — then run it many times.
  • Sessions: autonomous or interactive An AgentSession is one run — a fire-and-forget task or a multi-turn conversation.
  • Built-in, MCP, and custom tools bash, file, code, and web run inside the sandbox.
Explore AgentX
an agent is just a CRD 
$ kubectl apply -f agent.yaml         # a versioned Agent definition
agent.agent.tensorstack.dev/demo  created
$ kubectl apply -f session.yaml       # one run of it
agentsession/demo-run-1  created
$ kubectl get agentsession demo-run-1 -w
demo-run-1   Pending → Running → Succeeded   # hardened sandbox Pod
$ taip-agent trace demo-run-1          # live SSE: every step, tool call, token
# usage: 1,284 in · 412 out tokens · attributed to this run▌

Agent, AgentSession, AgentService, AgentSchedule, MemoryStore — five CRDs on agent.tensorstack.dev. Declarative, GitOps-friendly, observable with the Kubernetes tools you already run.

Release
v0.1.0-rc1 preview
CRDs
5 on agent.tensorstack.dev
Tracing
Step · tool · token

07 — Govern / 09

ConsoleX

Available

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.

Key capabilities

  • Per-user workspace, automatically On first OIDC login, ConsoleX creates a namespace, applies a quota template, and grants the user admin of their own namespace — no manual provisioning, no tickets, no custom RBAC.
  • Run workloads from the browser List, create, scale, restart, and debug Pods, Deployments, StatefulSets, Jobs, and CronJobs.
  • Quotas that hold Quota templates propagate live to every linked workspace.
Explore ConsoleX
first login, fully provisioned 
# alice signs in with SSO — ConsoleX provisions her workspace
namespace      cx-alice                          created
resourcequota  gpu-small (8 CPU · 32Gi · 1 GPU)  applied
networkpolicy  default-deny                      enforced
rolebinding    alice → admin of cx-alice         granted
# drift is repaired within seconds — watches + periodic sync▌

No manual provisioning, no custom RBAC. Admins define a quota template once; ConsoleX enforces it forever.

Setup
Per-user, automatic
Surface
Pods · PVCs · NetworkPolicies · YAML
Identity
OIDC SSO · token authority

08 — Operate / 09

TAIP Admin

Available

The whole AI cluster on one screen. kubectl optional.

A single-binary console for AI Kubernetes clusters: multi-vendor GPUs, Kueue, KServe, a storage console over Ceph and Longhorn, platform application health, alerts, idle-resource detection, identity management, an audit trail, and a full-screen War Room — every integration auto-detected, every absence handled gracefully.

Key capabilities

  • GPU and AI workloads, first-class Extended resources, DRA device browsing, and per-accelerator telemetry for NVIDIA DCGM and Ascend NPU — utilization, memory, temperature, power.
  • Storage you can actually account for Ceph clusters and Longhorn are discovered as storage backends — declared by a StorageBackend CRD that supplies fleet identity, console link, and metrics job — and every PV is joined back to the backend serving it.
  • The platform's own apps, watched A health view over the TAIP applications themselves — traffic signal per app, alerts attributed to the pod that raised them, and restart, scale, or rollback without leaving the page.
Explore TAIP Admin
integrations light up by themselves 
$ helm install taip-admin taip/taip-admin
detected   metrics-server ✓  kueue ✓  kserve ✓  cert-manager ✓
detected   gateway-api ✓  dra ✓  vpa ✓  training-operator ✓
connected  prometheus ✓  alertmanager ✓  grafana ✓   # one URL each
# remove a component and its pages vanish cleanly
# 617 secrets listed in 0.5s (metadata-only) · values never leave the cluster▌

One binary, one Helm release. The console grows and shrinks with your stack — across Kueue versions, without rebuilds.

Footprint
Single Go binary · one Helm release
Auto-detected
Kueue · KServe · DRA · cert-manager
Storage
Ceph · Longhorn · per-tenant GiB-hours
Identity
OIDC · admin/viewer split

09 — Install / 09

TAIP Base

Available

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.

Key capabilities

  • Air-gap first, not retrofitted Charts vendored, images packed as OCI layouts, versions pinned, K3s system images resolved from the K3s binary itself so nothing can drift.
  • One opinionated stack Kubernetes + Cilium (eBPF CNI) + Longhorn (replicated block storage) + MetalLB (L2 load balancing on bare metal) + cert-manager + Envoy Gateway (Gateway API) + a self-hosted OIDC identity provider + KServe for model serving (default on, opt-out).
  • Idempotent and tagged Every role is re-runnable; Ctrl-C and re-run is the documented recovery path.
Explore TAIP Base
idempotent from bare metal 
$ ./install/00-preflight.sh                      # read-only validation
$ ./install/03-install-cluster.sh --cluster site-a
ok  k8s · cilium · longhorn · cert-manager · envoy-gateway · authentik
# Ctrl-C and re-run is the documented recovery path
# same bundle, same registry, same result — across sites and months▌

Content-addressed bundles: re-packing a version bump moves only changed layers. One registry serves many clusters.

Networks
On-prem · restricted · air-gap
Stack
K8s · Cilium · Longhorn · Envoy · OIDC · Kueue
Bundle
Pre-staged · pinned · reproducible

§ 03 — Architecture

Twelve products. One coherent stack.

Each product is sharply scoped and ships on its own. Together they share identity, tenancy, policy, and observability — a platform, not a folder of tools. Pick any product to see where it fits.

All products

L5

AI applications

Knowledge and agents your teams build on

L4

AI lifecycle

Develop → train → register → serve

L3

Control plane

Tenancy, operations, and accounting

L2

Foundation

Kubernetes, identity, storage, networking

L1

Your hardware

On-prem · VPC · air-gapped

NVIDIA AMD Intel Ascend Cambricon Ceph · Longhorn

InferX

Available

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.

Protocols
OpenAI · Anthropic · streaming SSE
Runtimes
vLLM · llama.cpp · any KServe runtime
Hardware
NVIDIA · AMD · Intel · Ascend · Cambricon
Open product page

Standards as load-bearing interfaces — where one exists, we use it. We don't invent protocols.

  • ◆OCI
  • ◆OpenAI API
  • ◆Anthropic API
  • ◆MCP
  • ◆OIDC
  • ◆Gateway API
  • ◆KServe
  • ◆Kueue
  • ◆JobSet
  • ◆OTEL
  • ◆DRA
  • ◆Cosign
  • ◆eBPF

§ 04 — Why sovereign

Private by design. Unified by default.

Law firms don't send privileged files to outside vendors. Hospitals don't put patient records on shared servers. As AI handles your most sensitive work, it should meet the same bar.

01

One platform, the entire AI lifecycle

Notebooks, training, a model registry, inference, and agents — on a single, consistent stack. One identity, one quota model, one audit trail. Stop stitching together a dozen tools.

02

Governance is the product, not the homework

Per-user namespaces, quotas that repair their own drift, default-deny networking, OIDC everywhere, one token authority every product trusts, one SSH gateway, audit logs in one record shape, per-token cost attribution. The unglamorous parts, done first.

03

Yours to run, anywhere

Your data center, your VPC, or a fully air-gapped facility — by design, not retrofit. Identity is self-hosted. Images are pre-staged. No node ever needs the public internet.

§ 05 — Who it's for

Built for the teams that actually do the work.

TAIP is shaped around organizations where data control isn't optional — law firms, hospitals, financial services, government — and the research teams pushing the frontier.

01

AI research labs

From notebook to training run, without leaving the platform

Give researchers GPU-ready dev environments, curated training with live progress, and a clean handoff from experiments to production — all under the same identity and quota model.

Read more

02

AI product teams

Ship LLM-powered products on infrastructure you control

Stand up OpenAI- and Anthropic-compatible endpoints, host fine-tuned models, and meter every token on dedicated capacity — with the cost, latency, and privacy your product needs.

Read more

03

Platform & infrastructure teams

Run a serious internal AI platform without building one from scratch

TAIP gives platform teams the multi-tenant control plane, policy, and observability that turn a GPU cluster into a real product for the rest of the company.

Read more

04

Regulated & on-prem deployments

AI that meets your compliance bar — in your environment

TAIP installs into your data center, your VPC, or air-gapped environments. Bring your IdP, your network policy, and your hardware — TAIP fits in.

Read more

Bring the platform inside

Your hardware. Your IdP. Your data.

From bare hosts to a working AI platform — connected or fully air-gapped. See how the pieces fit, then see it on your own racks.

Explore the products See it by use case