Sovereign models
All of FACE’s inference, including text reasoning, vision and voice, runs on models served inside the FACE deployment’s own cluster: Runink’s shared machines on a Trial, your own cloud on Cloud, your own servers on On-premises. FACE calls no outside AI service on any plan. It also ships no inference binary: it is an HTTP client of the platform’s shared model plane.
The model plane contract
FACE talks to the plane through the OpenAI-compatible HTTP API:
| Purpose | Endpoint FACE calls | Base URL |
|---|---|---|
| Text and vision generation | POST /v1/chat/completions | INFERENCE_REMOTE_URL |
INFERENCE_REMOTE_URLis the only variable FACE reads for the plane. The vision and voice tiers (VISION_REMOTE_URL,VOICE_REMOTE_URL) default to it.INFERENCE_API_KEYis sent as a bearer token when set. FACE never generates a service token. A plane that requires one and a FACE configured without one fails per call with the plane’s own authorisation error.- Admission control is available.
FACE_ADMIT_MAXbounds concurrent inference calls at the one door every call passes through. It’s off when unset or0.
Deploying and sizing the plane is the platform’s job. See Operations.
When the plane is not configured
There is no local fallback tier, so a FACE with no plane has no inference at all. FACE refuses to run in that state, in two places:
At startup. If
INFERENCE_REMOTE_URLis unset or blank, the server refuses to start. The error names the variable and explains that FACE has no local model server.Per call. If a model call still reaches an empty base URL,
ModelServicereturns gRPCFailedPreconditionwith a message that names the variable. For example, fromGenerate:text generation is unavailable: no inference endpoint configured (INFERENCE_REMOTE_URL is unset or blank). FACE has no local model server
The rest of the message says it is a deployment fault in the platform’s manifests, not a transient error.
FailedPrecondition was chosen because retrying can’t fix it. It’s a configuration
state, and the FACE app can show the sentence verbatim.
ModelService
ModelService is FACE’s gRPC door to the plane. Every agent, deriver and extractor that
needs a model goes through it.
| RPC | Purpose |
|---|---|
Generate | Text or multimodal generation. |
Embedding | Deprecated. Answers Unimplemented: FACE does not compute embeddings. |
SynthesizeSpeech | Text to WAV audio through the in-cluster text-to-speech service. The engine has one voice; voice is accepted but only used as part of the cache key. |
SpeakFetchSummary | The spoken executive summary of the latest fetch, composed deterministically on the server. |
Task routing
GenerateRequest.task_type says which kind of model a call needs:
TaskType | Model id FACE sends | Routed to |
|---|---|---|
TASK_TYPE_GENERAL / TASK_TYPE_UNSPECIFIED | default | The general reasoning tier |
TASK_TYPE_CODE | coder | The code tier |
TASK_TYPE_VISION | vision | The vision tier |
The platform’s model router (run by TIDE) chooses the tier from that id.
GenerateRequest.model is deprecated and the server ignores it.
Which model answered
Every answer records which backend served it, as the router reported it, in
GenerateResponse.served_by (the router’s X-Runink-Served-By header, written as
<tier>/<model-id>@<host>, for example general/qwen3.8-27b@gx10). When the main
model could not answer and the router’s smaller fast tier did, fallback says why:
unreachable or training. The rate the answer was decoded at is in decode_tok_s,
with decode_rate_source saying where that figure came from (the engine’s usage block
or the router’s tier header). If the router sent no header, the configured model is
recorded instead, as configured rather than as reported.
FACE asks the router never to answer from the fast tier on calls whose output can act
outside the app (by default the Twins decision, its revision and its repair). Those
calls wait for the main model instead.
Images are typed
A picture travels in ImagePart (raw bytes, a mime_type, and a text_offset into
the prompt), never as base64 inside prompt text. The receiver base64-encodes it once,
when it builds the data: URL the plane expects. Because an image has its own field, a
string in untrusted text can’t be misread as an image.
ChatMessage.images carries images per turn in multi-turn
conversations.
No embeddings
FACE does not call an embedding model. Retrieval is Direct Corpus Interaction: passages are stored as plain text and searched by their words. See Grounding. The model plane serves FACE generation, vision and voice only.
Reading the results
- A configured URL is not a reachable plane. The startup refusal checks that someone wrote the variable down. It dials nothing.
- A reachable plane is not a loaded model. The plane can answer on its port while weights are still loading.
- Being sovereign doesn’t make a model accurate. This page describes where inference runs, not how good its answers are. The structural checks that bound model output are on Structured output and Agents & oversight.