Architecture
FACE is application code that runs on the Runink platform: a Kubernetes cluster (k0s) managed by TIDE. TIDE deploys FACE and supplies the shared services it relies on: the TLS edge, the inference plane, the service mesh’s certificate authority, the key that encrypts FACE’s data at rest, and the object store. Where the work runs depends on your plan; see Plans and billing.
FACE runs in its own namespace, face-system. Each deployment runs one FACE
instance, which TIDE’s operator manages.
flowchart TB
U[Browser: the FACE app] -->|HTTPS| E[Platform TLS edge]
E --> FE[face-frontend<br/>serves the app, proxies its calls]
FE -->|gRPC-web, same origin| CP[face-control-plane<br/>gRPC services]
subgraph ns [face-system namespace]
FE
CP
R[face-runner<br/>managed runner]
end
CP -->|in-cluster HTTP| MP[Inference plane<br/>text · vision · voice]
CP --> S[(Encrypted storage<br/>object store · metadata · records)]
CP -->|mutual TLS| R
R --> DS[(Your data sources)]
CP -->|mutual TLS| SR[Self-hosted runner<br/>in your network]
SR --> DS2[(Data sources behind<br/>your firewall)]
Components
| Component | What it does |
|---|---|
| face-frontend | Serves the Flutter web app and passes its calls (gRPC-web, sign-in and API paths) to the control plane on the same origin, so the app needs no backend address baked in. |
| face-control-plane | The FACE gRPC backend: runs, briefs, analysis, options, the twins and their decisions, follow-ups, remediation, camera and sensor feeds, and the other services in the API reference. TIDE’s operator renders it from the instance’s FaceInstance resource. |
| face-runner | The managed runner: a FACE process that reads your data sources from inside the cluster. It is the default runner for every connection. |
| Self-hosted runners | Runners you run in your own network, so reads happen close to the data. A runner enrols with a single-use setup ticket, and FACE reaches it over mutual TLS on its own runner certificate authority. |
| Inference plane | The platform’s shared language, vision and voice models, behind an OpenAI-compatible HTTP interface. FACE ships no model server and refuses to start without the plane’s address. |
| Storage | FACE’s encrypted file tree on the platform object store (sessions, users, connections, schedules, run records), a metadata database with its values sealed, and append-only logs for traces and data lineage. |
| Mesh | When a deployment names its mesh peers (RAFT_NODE_ID and RAFT_PEERS), the control plane’s peers replicate the connection registry over mutual TLS, with certificates from the platform’s certificate authority. Without them a pod does not join the mesh, and each fetch carries the connection records it needs to the runner instead. Credentials travel neither way: credential bundles stay on the node that holds them. |
Instances and access
An instance is defined on the platform as a ClientInstance resource that TIDE’s
operator owns. It names the people who may use the instance and until when. When you
sign in, FACE lists the instances you hold a grant on, read from those resources. It
never shows an instance you may not use, and never invents one when the list cannot be
read. See Sign in and choose an instance.
Where your data goes
- Model calls stay in the platform. Prompts, retrieved records and model outputs go only to the inference plane.
- Outbound calls go only to what you connect. That means your data sources, plus the web searches, messaging and email channels you configure. FACE calls no paid map or geocoding service.
- Credentials are separated from configuration. A connection record has no field that can hold a secret. Credentials go to a sealed credential store and are never returned through the API.
- At rest, data is encrypted under a key derived from the key-encryption key the platform provides. FACE refuses to start without it rather than fall back to plaintext.
Details and limits are in Security & trust. Deployment and configuration are in Operating FACE.