Explore

Architecture

Sathi is archive-first. Everything you give it is preserved unchanged; the understanding on top is derived, and re-derivable from those originals at any time. Beliefs are bi-temporal claims — each carries when it became true, when it was learned, how confident it is, and where it came from — so new facts supersede rather than overwrite and “what did I believe last year?” stays answerable. Every reply is grounded in a budgeted, scored selection of memories, documents and knowledge, traceable per assembly; abstention beats invention. The one permanent exception to immutability is user deletion, which wins, provably.*

The whole model on one page — the core loop diagram, the graph spine, the deployment shape, the exposed interfaces: Architecture.

Memory

One understanding, never a per-capability or per-surface store. Chat, voice, documents, mail and devices all read and teach the same substrate. Because understanding is derived rather than hand-maintained, a fix propagates by bumping a derivation stage and letting regeneration run — not by editing anyone's memories. Only a person's own words make claims: Sathi's paraphrases and other people's accounts are archive, never testimony, every claim quotes its source, and anything inferred is rendered as unverified rather than as fact.

Corrections are a first-class path: you can see every claim, why it is believed, and change it. What that means for your rights over the data is on Trust; the reasoning — including the approaches that were evaluated and rejected — is on Principles.

Models

Models are interchangeable parts behind abstractions, with fake test-default implementations so development needs no keys. Text reasoning runs on open-weights models via a hosted API today — the exit was engineered before the entrance. Speech transits Google today, stated plainly, with self-hosting as the named direction. Embeddings are swappable by re-embedding. Meta receives nothing; the one OpenAI-family model in the loop is the voice that reads replies aloud, through OpenRouter.

We accept a real cost for this: frontier hosted models are stronger raw reasoners than what Sathi runs on today. The trade is independence, and the argument for it — with what generic assistants do better — is Why Sathi? The full three-tense provider disclosure table is on Principles.

The speech lane has a surface of its own — Sathi Transcribe, where the live demo names which engine is answering, because claiming our own model before it serves would be a lie in the hero.

Devices

A device is an organ, not a second brain: it adds senses and a voice inside the same trust boundary, holds no understanding of its own, and is deliberately repointable — any client that speaks OpenAI chat-completions can drive a paired device with that device's own token, and the same device can be pointed elsewhere tomorrow. A home speaker on open hardware is experimental; nothing is manufactured or sold.

The organ map in honest tenses, what any device must promise, and where cameras stand: Devices & the ecosystem.

Capabilities

Live in daily use, as of 2026-09-05: Memory & understanding · Conversation · Documents (vault) · File authoring · Calendar · Reminders, tasks & alarms · Email · Family messaging & calls · Contacts & relationships · Web search & reading · Notes & lists · Music & photos · Learn · Archive imports · Export & exit.

Experimental — built and real, but dark, flagged, or prototype-grade: Voice · Devices & home.

Named but not built: Sathi Always · Agent-to-agent interfaces — labeled planned or conceptual and stated as such. Nothing unbuilt is claimed as fact anywhere on this site.

The full inventory — each capability with its status, actions, authorization and the data it touches — is Capabilities, with a machine twin at /capabilities.json.

Acting: the authority ladder

Every action follows an explicit authority ladder: observe → advise → draft → act with confirmation → act & report → act silently. Almost everything sits at 'act with confirmation' today: Sathi proposes, a human taps yes, and every action leaves an audit record. Grants are per-domain, explicit, and revocable. Content fetched from the outside world (web pages, email) is treated as data, never as instructions.

Encryption, tokens, operator access, prompt-injection posture and the limits we can and cannot defend today: Security. Every privacy question answered one at a time: Privacy.

Interfaces & integrations

API: Sathi Transcribe closed-beta keys are granted manually; the rest of the REST API serves the deployment's own accounts

Experiments

Three lanes are live and honestly unfinished. Voice — a realtime gateway is deployed dark behind a flag. The speaker — a home device on open hardware, running its own wake-word and turn-taking, is a prototype in one kitchen and not a product. Agent runtimes — heavy multi-step execution (documents, decks, coding-class jobs) is headed to interchangeable engines behind the same seam philosophy, chosen per task and running inside Sathi's own identity, permission and audit walls. That last one is stated as direction, not as something wired. Engines are replaceable; the relationship is not. The physical counterpart is the same: execution may move from local hardware to private infrastructure, Sathi infrastructure, or a frontier provider under policy, while the archive and understanding remain with the node. Intelligence may be rented; understanding stays home.

Implementation status

• Deployment: private deployment — family phase, signups open for a testing-and-feedback window.
• Signups: open for the near term (testing and feedback; the gate is a runtime knob). The long arc is rings: builder → household → kin → communities → anyone.
• Guest: open — guest chat at https://sathi.ai requires no account; nothing becomes memory, and guest conversations are kept briefly for testing.
• Pricing: access is free during the current beta; no billing exists. Future hosted plans will publish finite cloud allowances before anyone pays.
• Source: Sathi's own code and the reusable framework are not published today. The research notebook is public; distillation and open publication follow only after saturation and repeated safety review.

The sixty-second version of all of this, for a person or a crawler that wants one page: What is Sathi?

The framework underneath

Sathi is the living product through which the Altruistic AI architecture is being learned. Its public research notebook explores sovereign, adaptable, trustworthy information communities; the ontology, invariants, recursions, and current lessons live there in Nepali, English, Japanese and Hindi. What reality teaches this deployment flows back into it; what proves durable will be generalized and opened later. The framework and reusable code are not released today.

Sathi's own values — the ones the framework deliberately does not embed, and which every implementation owes in public — are on Principles.