Sovereignty and local-first
Sovereignty is the claim Apollia is built to make good on: your data, your models, and your runtime stay yours. "Local-first" is how that claim becomes concrete rather than aspirational. This page explains what those words mean in practice and why they are the core of the value proposition, not a feature bolted onto it.
The default never leaves the machine
The starting posture is the sovereign one. Storage is a local SQLite database.
The runtime's API binds to a Unix socket, reachable only by the owner of the
socket file, and also to TCP on 127.0.0.1:7771, where every request must carry
a Bearer token. Loopback means the listener is not reachable from the network at
all; opening it up is a deliberate edit of [api] bind. There is no telemetry
and no automatic upload of anything.
This is what "local-first" means operationally: the path that runs when you do
nothing special is the path that keeps everything on your hardware. Sovereignty
that you have to configure your way into is not sovereignty; here it is the
default, and leaving it is the deliberate act.
Windows has no Unix socket, so the local transport there is a named pipe,
\\.\pipe\apollia-runtime-<user>. It plays the socket's role but not with the
socket's guarantee: a pipe is created with a default security descriptor, weaker
than the 0600 the runtime sets on the socket file, so what gates access on
Windows is the Bearer token the pipe carries, not the transport's own
permissions. The TCP listener is bound on Windows exactly as it is elsewhere:
apollia-os start always passes a port.
Inference runs local
Apollia carries its own local inference. A model in GGUF format runs through a
supervised local engine (the embedded llama-server, upstream llama.cpp), and
on macOS Apple Silicon a model in the MLX format runs through a second embedded
engine, so the
reasoning that drives an agent can happen entirely on your machine with no external
LLM call. This is the piece that makes
the rest meaningful: local storage is not much of a guarantee if every thought
the agent has is a round trip to someone else's server.
One honest bound on the local inference available today: llama-server loads a
single-file GGUF model, so a model split across several files is not offered.
Embeddings are local too. An embeddings model you choose is served by the same
engine on the loopback interface, and it is what indexes your sources and
memory for search; with none chosen, search falls back to keywords alone.
Zero external dependency
Local-first only holds if running locally does not quietly require a fleet of services. It does not. The runtime needs no Docker, no Node, no external database, and no separately installed Python: the interpreter is embedded. One binary is the deployable unit. Every optional connection to an external service degrades gracefully instead of turning into a hard requirement. This is the second principle, and it is what keeps "local" from meaning "local plus five things you also have to run."
The cloud is a choice, never a default
A remote model exists as a choice. There is no dedicated cloud provider: a remote model is reached through one generic connection to an OpenAI-compatible server, at an address you designate, such as a server you host or a gateway you run. Nothing reaches a remote server until you configure one, and the local model stays the default.
What the opt-in buys is worth stating precisely, because it is the one place where
the runtime decides on its own. If you enable hybrid routing
([llm.routing.hybrid]), the runtime may escalate a turn to the frontier backend
without asking again at the moment it does so: today the trigger is three
consecutive tool failures in the same run. That is the shape of the opt-in. It is
not "the cloud stays untouched unless you press something each time", it is "you
decide once, per configuration, which conditions are allowed to reach out." Leave
hybrid routing off and no request ever leaves on its own.
The design treats the cloud as a capability you can reach for, not a dependency you inherit.
Your memory stays yours
An agent's memory, its episodic, semantic, and procedural layers, can be exported and imported by you. Each agent has one space of its own, named after it, which it reads and writes itself when Memory is checked on its sheet; nothing is put there on its behalf. That is not a convenience feature; it is the concrete form of ownership. Data you can take out, inspect, and move is data that is yours in a way a privacy policy cannot promise. Portability is what turns "we store it locally" into "you hold it."
Why this is the core, not a feature
Every other strength of Apollia rests on this one. Accountability means little if the record lives on a server you do not control. Autonomy is hard to delegate if delegating it means shipping your data offsite. Sovereignty and local-first are the constraint that shapes every default, which is exactly why they read as the first two of the eight principles rather than as options in a settings page. For where this sits in the architecture, see the sovereignty section of Cross-cutting concepts and the Constraints page. For the actual configuration knobs (socket versus TCP, backend selection), see the Configuration reference.