Architecture
This page explains how Runink TIDE is built: what runs on the cluster, and how trust, data and traffic move through it.
What TIDE is, and what it is not
TIDE is the shared platform for the Runink applications (FACE, PULSE and LUNA), and FORGE is one of its own console categories. Platform concerns live here: self-healing, the event mesh, secrets, the object store, inference serving, MCP, PKI and mTLS, telemetry, the Kubernetes operators and the infrastructure as code.
The apps do not import TIDE. Code that more than one app runs lives in a shared library that TIDE and the apps both import.
Components
| Component | Role |
|---|---|
tide | the CLI, the single control surface: dev stack, deploys, images, security scans, sessions, the install wizard. See the CLI reference. |
| TIDE console | the web console, served by the TIDE operator. |
| Operators | one Kubernetes operator each for FACE, PULSE and TIDE’s generic ClientInstance. |
devgateway | the edge: a DaemonSet on host ports 80 and 443 that terminates TLS with a leaf from TIDE’s own CA and routes each host to its frontend. |
ambassador | a small static mTLS TCP proxy. Its image is FROM scratch. |
modelrouter | the one admission queue in front of the inference engines. |
forgecheck | the verifier central CI runs on FORGE projects. |
tide-runner | the self-hosted data-access runner. |
What runs on the cluster
Deployments use k0s with pure kustomize overlays (no Helm). The operators are the authoritative source of each pod’s spec and environment.
ClientInstance
ClientInstance (core.runink.org/v1alpha1) is the generic tenant instance the platform places on a
shared cluster:
| Field | Meaning |
|---|---|
app | the application identity. Drives the core.runink.org/app label and the dedicated-taint toleration. |
tenant | the tenant key. The core.runink.org/tenant label plus soft node affinity. |
role | controlplane or runner (default runner): selects the PriorityClass. |
image | the container image to run. |
port | the container and service port (default 8080). |
replicas | default 1; ignored when suspend is true. |
computeUnits | a sizing budget, mapped to real CPU and memory limits. It is not the billed Compute Unit (one model-slot second); see Plans and billing. |
tags | client labels added to the pod template and ServiceAccount. |
placement | nodeSelector, tolerations (added to the defaults), affinity (replaces the default soft affinity). |
env | extra environment variables. |
users | access grants: email, role (admin, writer or reader, default reader), optional phone, optional expiresAt. |
subscription | tier (lite, dedicated or enterprise), seats, status (active, suspended or past_due). |
suspend | scale the instance down. |
Every operator gives each pod the same isolation labels and scheduling:
core.runink.org/{app,tenant,role}, runink.org/{app,tenant,role}, the toleration
core.runink.org/dedicated=<app>, soft (anti-)affinity and a priorityClassName. Each namespace
carries a ResourceQuota, LimitRange, PriorityClass, NetworkPolicy and PodDisruptionBudget.
Trust: defence in depth
Everything internal is authenticated and encrypted.
- PKI. Every workload holds a short-lived ECDSA leaf signed by the shared cluster CA, and
internal connections use mutual TLS.
tide mesh camints and distributes that CA. - Encryption at rest. Envelope encryption (AES-GCM) is applied by the object store and the
connection store, always. Anything that opens either store needs
TIDE_ENVELOPE_KEKand refuses to start without it. - The object store. TIDE runs its own S3-compatible
objectd, which verifies SigV4. The TIDE operator mints every objectd key as a Secret in the consumer’s namespace. - App databases. FACE and PULSE seal database values per column before they are written.
Where the console keeps its data
The console keeps its metadata in its own encrypted root:
- on objectd, when
OBJECTSTORE_ENDPOINTand both credentials are set. If objectd is configured but cannot be opened, the console fails closed instead of falling back; - otherwise in a local encrypted directory,
CONSOLE_APPFS_DIR(default/var/lib/tide/appfs), on its persistent volume.
Each store (agent health, schedules, runs, lineage, governance findings, judgements, rules
reconciliation, session commands and runs, GitHub config, cloud providers, connections,
subscriptions) is a table in that root. The audit chain is a hash chain that continues across
restarts, and GET /api/audit/verify walks it.
The console republishes the few settings the agents read after every change, so change them in the console: an edit made anywhere else is replaced on the next write.
Traffic: the edge and the apps
Each app’s web UI is served by its own small frontend, which serves the Flutter bundle and
reverse-proxies gRPC-web, /auth/* and /api/* to the backend. The devgateway edge routes /
on each host to that frontend, except gRPC-web calls, which it sends straight to the app
backend. Native gRPC (the mobile and desktop apps) also goes to the frontend, and is
carried there over cleartext HTTP/2 (h2c) so its trailers survive.
The devgateway has its own sign-in gate. When edge auth is on, an empty
DEVGW_AUTH_ALLOWED_EMAILS refuses every sign-in. Admitting any verified Google account needs
the explicit DEVGW_AUTH_ALLOW_ANY_VERIFIED=true. Edge sessions are kept server-side.
FORGE runs inside the TIDE console (FORGE › Studio is a console route), on TIDE’s session.
Inference
The model plane is sovereign: no hosted model is called. mistral.rs is the engine of every language tier. The model
router is the one admission queue in front of the engines, and every app and agent calls it by
tier. Each tier’s backend is one router setting (BACKEND_<TIER>):
- general and coder (one Qwen3.8-27B), guard, reranker and stt are served by one inference server outside the cluster, reached through servefwd, which forwards one port per tier and keeps the server’s bearer out of every pod;
- embedding, vision and imagegen are served on the cluster itself.
Servers are attached dynamically: the off-cluster servers are declared in the tide-servers
ConfigMap and appear on DevEx › Clusters › Nodes & servers. Agent budgets derive from a configured decode
rate, INFERENCE_DECODE_TOK_S. See Models & inference.
Delivery
There is no Argo CD. Delivery is GitHub Actions: tide-cd.yml builds the images a merge changed,
applies the kustomize overlays, rolls the workloads, and records each deploy in the console’s
lineage record, which DevEx › Clusters › GitOps and Audit Chain › Deploy lineage read.
Networking
Manifests work on IPv6 single-stack, IPv4 single-stack and dual-stack clusters: services bind
[::], and no Service is pinned to one address family.
Images
tide build builds local podman images only. The images the cluster runs are built in the
cluster (werf and buildah in an ephemeral Job) and pushed to the node-local registry. Every
Dockerfile pins its base image by @sha256: digest, and the base images are mirrored with
tide images mirror.
After a delivery roll, workloads run a digest-pinned :latest@sha256:…. A bare
kubectl rollout restart then restarts onto the same digest. To move a workload onto new
images, run the delivery workflow for that image.