Your AI belongs to you.
ownify is a personal AI that runs entirely on your own device — your laptop, your desktop, your phone. It learns how you think, how you work, and what you know. That knowledge stays with you. Always.
Today's AI assistants store your conversations, your preferences, and your patterns on someone else's servers. Your personal knowledge becomes their training data. You don't own your AI — they do.
ownify is a small, fine-tuned local language model that:
- Runs on your device — no cloud required for everyday tasks
- Carries your knowledge in its weights — not in config files, not in databases, but baked into the model itself
- Knows when it needs help — and can escalate to a larger LLM API when a task exceeds its capability, then returns to local-only operation
- Stays minimal — no platform, no server infrastructure, no ecosystem. One model, one person.
-
Personal, not shared. ownify is designed for one person. It is not a platform. It will never be a platform. Your personal AI should belong to you alone.
-
Behavior lives in the weights. Instead of system prompts, configuration files, and prompt templates, ownify bakes personality, knowledge, and behavior directly into the model through fine-tuning. The model is the configuration.
-
Smart escalation. The local model handles most tasks. When it recognizes something beyond its capability, it calls out to a larger model API, gets what it needs, and comes back. You control when and where that happens.
-
Runs where you are. Desktop or mobile. Offline-first. Your AI goes where you go.
ownify's default behavior comes from openclaw — an open-source LoRA adapter modeled on OpenClaw agent behavior patterns:
- Direct and efficient — no performative language, gets to the point
- Genuine helpfulness — resourceful before asking for help
- Honest about limitations — says "I don't know" when it doesn't
- Learned escalation — recognizes when to call a larger model
- Fully transparent — training data, scripts, and weights are all public
openclaw is the shared foundation. Your personal adapter layers on top with your style, knowledge, and preferences. Together: base model + openclaw + personal adapter = your ownify.
You ask something
|
v
ownify (local, small model)
|
|--> Can handle it? --> Responds directly (fast, private, free)
|
|--> Needs more? --> Escalates to large LLM API --> Returns answer locally
When ownify escalates to external models or interacts with other agents, trust matters. ownify integrates the MolTrust Protocol by MoltyCel for decentralized agent identity and verification:
- Agent identity — Ed25519 keypair stored locally, registered as a W3C Decentralized Identifier (DID)
- Escalation trust — verify external agents before sending your data to them
- Output provenance — cryptographic proof of what your agent did (Interaction Proof Records)
- Offline verification — cache public keys from Base L2 blockchain, verify without network
No central authority. Your identity is a local keypair. Trust is cryptographic, not assumed.
See ARCHITECTURE.md for full integration design. Built on MolTrust — all credit to MoltyCel for the protocol.
# Clone
git clone https://github.com/HaraldeRoessler/ownify.git
cd ownify
# Setup Python environment
python3.12 -m venv .venv
source .venv/bin/activate
pip install mlx-lm
# Train the openclaw adapter (~10 min on Apple Silicon)
python src/training/prepare_mlx_data.py --input data/openclaw-v2.jsonl --output data/mlx-openclaw
mlx_lm.lora --config configs/openclaw-mlx-v2.yaml
# Chat with your model
python src/runtime/chat.py- Base model: Qwen 3.5 4B — strong multilingual, good reasoning at small size
- Training framework: MLX — Apple's native ML framework, optimized for Apple Silicon unified memory
- Fine-tuning: LoRA adapters via mlx-lm (~10 min training, 9.7GB peak memory on M3 Pro)
- Inference: MLX native — no GGUF conversion needed, direct adapter loading
- Escalation: Planned — tool-call pattern to external API (configurable endpoint)
ownify/
├── README.md
├── ARCHITECTURE.md
├── LICENSE
├── configs/ # MLX training configurations
│ └── openclaw-mlx-v2.yaml
├── data/ # Training data (open source)
│ ├── openclaw-v2.jsonl # 184 core behavior examples
│ ├── openclaw-training.jsonl # Additional examples
│ ├── training-openclaw-125.jsonl
│ ├── training_data.jsonl # Multi-turn conversations
│ ├── openclaw-training-data.jsonl
│ └── OPENCLAW_BEHAVIOR.md # Behavior specification
├── src/
│ ├── runtime/
│ │ └── chat.py # Interactive chat (MLX)
│ └── training/
│ ├── prepare_mlx_data.py # Data preparation for MLX
│ ├── train.py # PyTorch training (legacy)
│ ├── merge_and_export.py # Model merging
│ └── convert_to_gguf.py # GGUF conversion
├── adapters/ # Trained adapters (gitignored)
└── models/ # Merged models (gitignored)
The openclaw behavior is defined by conversation examples — not system prompts. All training data is in the repo:
| File | Examples | Content |
|---|---|---|
openclaw-v2.jsonl |
184 | Core behavior: identity, privacy, escalation, technical tasks, multilingual |
openclaw-training.jsonl |
125 | Identity, privacy, local handling, escalation, general helpfulness |
training-openclaw-125.jsonl |
125 | Values, capabilities, technical tasks, conversational, training/customization |
training_data.jsonl |
125 | Multi-turn conversations, edge cases, domain knowledge, daily use |
openclaw-training-data.jsonl |
125 | Multilingual, code review, DevOps, creative writing, error handling |
Total: 684 examples available for training. Currently training on v2 (184 examples).
- Base model selection (Qwen 3.5 4B)
- Training data format and collection pipeline
- LoRA fine-tuning pipeline (MLX on Apple Silicon)
- openclaw behavior adapter v2 (184 examples)
- Desktop runtime — interactive chat via MLX
- Merge all 684 training examples into openclaw v3
- Escalation runtime — automatic API calls when model flags
<escalate /> - MolTrust integration — DID identity, escalation trust verification, output provenance
- Personal adapter training guide
- Mobile runtime (iOS, Android)
- LoRA adapter sync between desktop and mobile devices
- Incremental learning — update the adapter from conversations
The individual pieces exist — no one has combined them.
- OpenClaw — the agent behavior our openclaw adapter is modeled on. Direct, efficient, genuine helpfulness, SOUL.md personality framework.
- MolTrust by MoltyCel — decentralized trust protocol for AI agents. W3C DIDs, Ed25519 signatures, Base L2 blockchain anchoring. ownify's trust layer is built on MolTrust. GitHub
Ollama, LM Studio, GPT4All, llama.cpp — all run models locally but offer no personal fine-tuning, no escalation, no cross-device sync.
- OpenDAN (~70% aligned) — personal AI OS with LoRA support, but routing is config-based, not learned.
- Khoj (~60% aligned) — self-hosted personal AI with knowledge base. RAG-focused, no LoRA fine-tuning.
- RouteLLM (ICLR 2025) — trains routers to select between weak/strong models. Cloud-only.
- "Tell me about yourself" (ICLR 2025) — proves fine-tuned LLMs can introspect on their own capabilities.
- MLX — Apple's ML framework, native to Apple Silicon. What ownify uses.
- Hugging Face PEFT — LoRA adapters, cross-platform.
- MobileFineTuner — LoRA fine-tuning on mobile phones.
No existing project combines: (1) behavior in weights via LoRA, (2) learned self-escalation, (3) desktop-mobile adapter sync, (4) single-person design. That's ownify.
- Apple Silicon Mac with 16GB+ RAM (for training and inference)
- Python 3.10+
- ~4GB disk for base model download
- Optional: API key for a large LLM provider (for escalation)
Note: Linux/CUDA support possible via PyTorch training path (src/training/train.py), but MLX on Apple Silicon is the primary and recommended approach.
MIT License — see LICENSE