San'e (صانع) — Arabic-First Personal AI Assistant for the GCC

San'e (صانع, "The Maker") is a self-hosted personal AI assistant written in TypeScript/Node.js and localized for Arabic speakers in the Gulf. It is described by its authors as a localized fork of the OpenClaw framework (MIT). San'e defaults to a Gulf-Arabic persona, shows Hijri and Gregorian dates together, and ships GCC-specific skills: prayer times, Ramadan mode, and Kuwait government portals. It talks to users over Telegram, WhatsApp, or a terminal chat, and generates responses with the Anthropic API.

The project is aimed at individuals and developers in the GCC who want an Arabic-first assistant they run on their own machine or VPS.

This repository is a working folder, not a trained model. It holds several snapshots of the San'e codebase (see Repository structure).

Author: AgenThink, Kuwait City

Arabic documentation: README.ar.md (v4) · README.ar.md (v1)

Key features

Arabic language layer

The Gulf-Arabic system prompt is defined in src/agent/index.ts: a warm, professional register, neither formal MSA nor slang.
Arabic-first onboarding wizard (src/cli/onboard.ts) and Arabic i18n strings (src/i18n/ar.ts).
The default language, locale and timezone are set through environment variables (ar, ar-KW, Asia/Kuwait in docker-compose.yml).

GCC cultural skills (skills/, each with a SKILL.md and skill.ts)

Skill	Purpose
`prayer-times`	Prayer times for 7 GCC cities via the Aladhan API, with proactive reminders
`ramadan-mode`	Detects Ramadan from the Hijri calendar, gives Iftar/Suhoor times and adjusts the assistant's tone
`hijri-calendar`	Shows Gregorian and Hijri dates together and converts between them, with a local calculation fallback
`kuwait-gov`	Directory of Kuwait government portals (MOI, PACI, MoH, MoE, Municipality, e-Government)
`agenthink-institutional`	Placeholder bridge to the planned San'e Business / AgenThink Institutional tiers

Additional components in v4 (sane-assistant-v4/)

Long-term memory: src/memory/vector_db.py stores facts in a local ChromaDB collection with gemini-embedding-001 embeddings, and the agent injects retrieved facts into its system prompt.
knowledge-extraction skill: manages what gets learned and how memories are retrieved.
agent-orchestrator skill: a "Meta-Orchestrator" (المدير العام) that routes each request to the most suitable skill. It includes stub models for a performance monitor, a conflict resolver and a resource allocator.
retail-suite skill: 12 retail and supermarket agent models (Price Scout, Co-op Finder, Offer Hunter, Loyalty Manager, Freshness Inspector, Pantry Tracker, Nutri-Halal, Cart Optimizer, Delivery Liaison, Recipe-to-Cart, Budget Controller, Bulk Buy). The v4 README marks 8 of the 12 as stubs.

Channels and deployment

Telegram via grammY and WhatsApp via Baileys (QR-code pairing), plus a terminal chat mode.
A gateway with a /health endpoint and a status dashboard on port 18789.
A multi-stage Dockerfile (Node 22 Alpine), docker-compose.yml, and a one-command installer script (scripts/install.sh) for Ubuntu and macOS.

Repository structure

Path	Description
`sane-assistant/`	San'e v1.0.0 (GCC cultural skills, Telegram and WhatsApp channels). This is the working copy: it has a newer WhatsApp message handler and local run logs (`*.log`).
`sane-assistant-v4/sane-assistant/`	The most feature-complete snapshot: v1 plus vector memory, the orchestrator and the retail suite.
`home/ubuntu/sane-assistant/`	An earlier export of v1 (same as `sane-assistant/` except for the WhatsApp channel).
`index.ts`	A stray copy of `sane-assistant/src/agent/index.ts` (the `SaneAgent` class). Its relative imports do not resolve at the repository root.
`docker-compose.yml`	A top-level copy of the San'e Docker Compose file.

Layout inside each sane-assistant snapshot:

sane-assistant/
├── src/
│   ├── agent/            # SaneAgent: Anthropic client, system prompt, skill context
│   ├── channels/         # telegram/ (grammY), whatsapp/ (Baileys)
│   ├── cli/              # onboard.ts (setup wizard), chat.ts (terminal chat)
│   ├── cli.ts            # `sane` CLI: start | onboard | chat | status | skills
│   ├── config/           # environment-based configuration
│   ├── gateway/          # HTTP gateway, /health, dashboard (port 18789)
│   ├── i18n/             # Arabic strings
│   ├── skills-loader/    # discovers and loads skills/
│   ├── memory/           # (v4 only) vector_db.py — ChromaDB + Gemini embeddings
│   └── utils/logger.ts
├── skills/               # one folder per skill: SKILL.md + skill.ts
├── docs/demo-conversation.md
├── scripts/install.sh
├── Dockerfile, docker-compose.yml
├── .env.example
└── package.json, tsconfig.json, CHANGELOG.md, LICENSE

Getting started

Requirements: Node.js 22+, plus Docker and Docker Compose if you deploy to a VPS. The v4 memory module also needs Python 3 with chromadb and google-generativeai.

cd sane-assistant-v4/sane-assistant      # or sane-assistant/ for v1
npm install                              # postinstall compiles TypeScript (tsc)
cp .env.example .env                     # then fill in your own values
npm run onboard                          # Arabic-first setup wizard
npm start                                # start the gateway and channels

Other scripts in package.json: npm run dev (watch mode), npm run chat (terminal chat), npm run sane -- <start|onboard|chat|status|skills>, npm run build.

The upstream README also shows pnpm install / pnpm sane .... Its install instructions point to a placeholder GitHub URL (your-org).

Docker (VPS):

cp .env.example .env
docker compose up -d --build
docker compose logs -f     # dashboard: http://<host>:18789

Environment variables (names only; see .env.example):

Group	Variables
Model	`ANTHROPIC_API_KEY` (required), `SANE_MODEL`, `GEMINI_API_KEY` (v4 memory)
Locale	`SANE_LANGUAGE`, `SANE_LOCALE`, `SANE_TIMEZONE`, `SANE_LOCATION` (`kuwait_city`, `riyadh`, `dubai`, `abu_dhabi`, `doha`, `manama`, `muscat`)
Gateway	`SANE_GATEWAY_PORT`, `SANE_GATEWAY_HOST`
Channels	`TELEGRAM_BOT_TOKEN`, `TELEGRAM_ALLOWED_USERS`, `WHATSAPP_ENABLED`
Security	`SANE_DM_POLICY`, `SANE_ALLOWED_USERS`
Persona	`SANE_ASSISTANT_NAME`, `SANE_ASSISTANT_NAME_EN`, `SANE_USER_NAME`
Features	`SANE_PRAYER_REMINDERS`, `SANE_RAMADAN_MODE` (`auto`/`on`/`off`), `SANE_HIJRI_DATES`, `SANE_AGENTHINK_ENABLED`
Logging	`LOG_LEVEL`

A sample Arabic conversation is in docs/demo-conversation.md.

Limitations

Not a model. San'e calls hosted LLM APIs (Anthropic for chat, Google Gemini for embeddings in v4). No weights are included, and you need your own API keys.
Model default is inconsistent. The READMEs and CHANGELOG say Claude Sonnet 4.6, but .env.example and docker-compose.yml default SANE_MODEL to claude-sonnet-4-5.
Many v4 agents are placeholders. Most retail-suite agents and all three orchestrator sub-models are stubs. Price Scout returns hard-coded sample results rather than live retailer prices.
v4 memory is not fully packaged. The memory module is Python, called from the Node agent. package.json lists Python packages (numpy, google-generativeai) as npm dependencies, so you must install the Python environment separately.
Three overlapping snapshots. There is no single canonical source tree. Use sane-assistant-v4/sane-assistant/ for the fullest feature set.
Untested. No automated tests are included.
Unofficial data. Prayer times depend on the external Aladhan API. Government portal links are static and may go out of date.

License

MIT. San'e is a derivative of OpenClaw, which is also MIT-licensed. See LICENSE in each snapshot.

Citation

@software{agenthink2026sane,
  title        = {San'e: An Arabic-First Personal AI Assistant for the GCC},
  author       = {{AgenThink}},
  year         = {2026},
  address      = {Kuwait City, Kuwait},
  url          = {https://huggingface.co/agenthinkmesh/Openclaw-Sane}
}

Downloads last month: -; Downloads are not tracked for this model. How to track

Inference Providers NEW

This model isn't deployed by any Inference Provider. 🙋 Ask for provider support