Skip to content

This page is in English.Overview in five languages

Architecture

How Sathi stays one Sathi on every device: what it keeps, how it changes its mind, and where it runs.

Updated 2026-11-15. This page is in English. · Overview in five languages · Machine-readable guide · What the * means

A cross-section of Sathi. On one line stand the surfaces a person reaches it from, with Sathi at the head of the line. From Sathi one thread runs down: the understanding derived from the person's words branches from it, and it ends at the archive of the person's own words and files, where each new line of understanding is tied to the sentence it came from. Under everything is a wall with one opening, and outside it a model, which can be swapped for another.
Surfaces Phone, laptop, speaker⁠*
Understanding Rebuilt from the archive

A reminder: today at six

Grandma: someone you call

“Remind me at six to call Grandma.”

Archive Your words and files, kept as they arrived
Authority The server decides
Models Rented, replaceable

One Sathi, many surfaces

No device or app keeps a memory of its own, so you do not repeat yourself to each one. A phone, a laptop, a speaker⁠* or an assistant you connect⁠* joins your account by a sign-in or a pairing. Each one reads the same understanding and acts under the same authority and audit as chat. The model only proposes. The server decides, and asks you when it must. What a device must promise is on Principles; each one's status, on Explore.

Underneath is one graph. Each person belongs to themselves. Belonging to a family or a company is a link they consented to and can revoke. Every app is a permitted view of the graph. Today: you can switch between the contexts an administrator has set up by hand (a family, a workplace) and see each one's home, apps and chat.

What is kept, and what is rebuilt

  • Kept. Your own words and files, and what you have confirmed, stay exactly as they arrived until you delete them. Deleting removes the live records and everything worked out from them. Backups and downstream retention are separate.⁠*
  • Rebuilt. Everything Sathi works out from your words is derived, never edited by hand. A better model or derivation step rebuilds it from the same archive. Your corrections, rejections and requests to forget are applied again, so nothing you removed comes back. Each new version is measured first, and the old one is kept for a while to roll back to.⁠*
  • Only your own words make claims. Sathi's paraphrases and other people's accounts stay in the archive and are never testimony. Every claim quotes its source, and anything inferred is shown as unverified. You can see why each claim is believed, and correct it.

How it feels, in plain words →

How a belief changes

A new fact never overwrites an old belief. Each belief is a bi-temporal claim. It carries when it was true, when Sathi learned it, how confident it is and where it came from. So "what did I believe last year?" stays answerable.

the old beliefThe family lives in Kathmandu.believed true since Nov 2025 · from: a conversation · confidence: high
the new evidenceWe've moved — home is Osaka now.today · from: you, in chat
That changes something I believed — that home was Kathmandu, since last November. Did the move happen? I'll keep the history either way.
Yes — we moved last month.
superseded — keptThe family lives in Kathmandu.closed, not erased: "where did we live last year?" stays answerable
currentWe've moved — home is Osaka now.valid from last month · provenance: your confirmation
One correction reaches every surface at once: chat, brief, search, reminders.

Choices we evaluated and rejected, after studying the memory-system literature and practice (mem0, Zep/Graphiti, Letta/MemGPT, MemOS, LongMemEval, and practitioner post-mortems):

  • No graph database. Relationships live as structured rows; a graph engine added operational weight without adding answers at our scale.
  • No fine-tuning as memory. Understanding lives in data we can inspect, correct, and delete, not in opaque weights.
  • No memory service from a vendor. Understanding is the part we answer for; handing it to a vendor would hand over that responsibility too.

Where it runs

Identity, archive, understanding and permissions belong to your Sathi. They do not move because a task needs different compute. Each task runs on the nearest place that is both capable and authorized:

  1. This device⁠* · planned

    Wake, voice, basic reasoning, cache and home control would stay local; harder work would go further only where you allow it.

  2. Your own hardware⁠* · being tested

    A computer at home and an open-hardware speaker are testing how Sathi stays present at home, and what a device may do.

  3. Sathi’s server (Works today)

    One Sathi-operated private deployment.

  4. A model provider (Works today)

    One request at a time, with the context that task needs. Text you keep is also sent piece by piece to be indexed for search. What leaves, one by one

How it is deployed

  • One Sathi-operated VPS, Docker Compose: FastAPI backend, Postgres (+ pgvector) for archive/claims/vectors, a static Next.js client served by Caddy, LiveKit for family calls, SearXNG for web search. Nightly backups are encrypted before they leave the server and stored off-site in two places. On 2 September 2026 a full restore from one of them was verified. Where they are kept, and for how long, is Trust's deletion entry.
  • Encryption, scoped tokens, quotas and the audit log: Security.
  • Model providers sit behind abstractions with fake test defaults; embeddings are swappable by re-embedding. What leaves, and to whom, is on Trust and Privacy.

Not built yet⁠*

  • Your Sathi comes with you. A workplace or a club is one relationship and holds only the slice of you it was given. For anything personal it asks your Sathi, and your Sathi asks you. With it come contexts found at any depth and a public interface to the graph.
  • Independent deployments. Hardware, storage, keys, inference and network you control, able to continue without Sathi Systems. Organizations can talk to us on sathi.systems; nothing is signed today.
  • Agent runtimes. Heavy multi-step work on interchangeable runtimes, under the same permission and audit rules.

The status of each, and of every interface Sathi exposes: Explore.