A local-first AI that maps how your thinking evolves
By ContainAI – Building ethical AI infrastructure
Zynkbot is a private AI assistant for your phone and computer, built in Rust. The same Rust backend — memory system, ML inference, and encrypted device sync — runs on Android and desktop. It connects to Claude, GPT, Grok, or Mistral through your own API keys; your conversations and memory stay on your devices and sync privately between them over encrypted LAN. No subscriptions required — for typical conversational use, expect an estimated $5–15/month in API costs, versus $20/month per provider for subscription apps (cost breakdown). Local GGUF models are supported for fully offline, zero-cost use on desktop. Android uses cloud API models or Ollama proxied from a paired desktop over your home network.
Current Status: 
main branch tracks the current beta; stable releases are tagged. iOS planned.
Most tools that remember things for you either store facts (notes, journals) or store conversations (AI assistants). Zynkbot does something different: it builds a structured, relational memory of not just what you've thought and decided, but how your understanding changed over time — which beliefs shifted, which ideas connected, where new information contradicted the old. It's closer in spirit to Obsidian or Roam than to a chatbot, but where those hold static notes, Zynkbot maintains a living memory graph that tracks the evolution of your own thinking.
There's no account to create. No email verification, no periodic login codes, no password resets — you install it and run it, the way software used to work. That's possible because there's no company in the middle: every memory Zynkbot builds lives in a database on your own device, and nothing leaves it unless you choose.
Zynkbot wasn't built to be anti-surveillance software by ideology. But when mainstream AI assistants store your conversations on corporate servers, train future models on what you tell them, and show you nothing of what they've kept — a record of your thinking, held by someone else, working for someone else — then keeping your own memory on your own machine stops being a niche privacy preference. It's become ordinary self-defense, for ordinary people.
The memory system is the core. Every conversation is processed into structured memories — facts, preferences, context, and the relationships between them — stored locally and retrieved semantically. Over time, that accumulated structure is your Zynkbot: the understanding you've built together. The underlying AI model is just the face — swap it for a different local model or switch cloud providers without losing anything. In this sense it's less like a chatbot and more like the computer aboard the Starship Enterprise: not because it talks to you, but because it never forgets what you've told it. It will come to know you well, and it's genuinely useful to talk to — but it isn't a replacement for the people in your life, and it isn't trying to be. It's a tool for understanding yourself, not a substitute for your relationships with other people.
The kitchen is the plainest example of what that memory is for. Tell Zynkbot what you cooked and how it went, in whatever words you like. Ask it later what to make, and it remembers what you liked, what you refused, and how you are trying to eat. If you fall off a diet, tell it to forget those weeks and start again, because the memory is yours to edit. This is becoming the free Kitchen kit: a packaged, opt-in use of the memory system, in development for v1.0. Kits will run on your device, stay off unless you turn them on, and can be deleted as a group.
Zynkbot also runs a networking layer entirely on your local network. ZynkSync keeps your memory database consistent across your own devices. ZynkLink enables direct file transfers between paired users. ZChat provides device-to-device messaging with no cloud relay. Download a colleague's project directly into your knowledge base and Zynkbot is instantly familiar with it — without any of it touching a third-party server.
And because the entire stack is offline-first — no cloud dependency, no subscription, no internet required — the same infrastructure that protects one person's memory also works where connectivity can't be assumed: field work, disaster response, resource-limited regions. A snap-in architecture customizes the platform for specific domains — healthcare, legal, research, enterprise — on the same local-first foundation. → Digital resilience documentation
→ See how these features work in practice
Zynkbot has been in private development since 2024. This public repository was re-rooted in June 2026 because the original git history contained personal information — the commit history here reflects only the period since open-sourcing.
Contents
- Key Features
- Installation
- Project Structure
- Architecture
- Memory System
- Containment Modes
- Networking Features
- LLM Backends
- System Requirements
- Use Cases
- Contributing
- License
Key Features
- Persistent Semantic Memory - Transparent, editable recall with hybrid entity + semantic search
- Kits (in development for v1.0) - Opt-in packaged uses of the memory system; the Kitchen kit will be included free, with others planned as one-time purchases
- Privacy-First - Local-first architecture, no telemetry, optional API use
- Safety Modes - Guardian, Child, HIPAA, Sovereign, Witness containment modes
- Pure Rust ML - Embeddings, NER, and safety classification run on the Candle framework — no Python runtime
- Multi-Model Ensemble - Query multiple AI models simultaneously with consensus detection
- Contradiction Detection - Automatically surfaces conflicting memories and asks you to resolve them
- Memory Graph - Visual relationship map of all stored memories; explore contradictions, connections, and context
- Cross-Device Sync - ZynkSync syncs memories across your own devices
- File Sharing - ZynkLink transfers files directly between paired Zynkbot users
- ZChat - Direct device-to-device messaging without cloud relay
- Web Search - On-demand live web search integrated into conversation when current information is needed
- Knowledge Base - RAG with semantic search over your uploaded documents
- No Login Required - Once installed, just open it. No accounts, no verification codes emailed to you, no password resets
- Conversation History - Persistent log of all conversations; browse by date, full-text search, resume past sessions
Open Beta — v0.9
Zynkbot is functional and the core systems — memory extraction, hybrid semantic search, contradiction detection, ZynkSync, and containment modes — work as designed. This is not a prototype.
What v0.9 needs is real-world use.
Development testing validates that features work under controlled conditions. It cannot replicate the full range of how different people talk, what they tell an AI, how a memory database grows over months, or what edge cases emerge across thousands of users instead of one developer. The memory system in particular — deciding what's worth storing, catching contradictions, retrieving the right context — gets meaningfully better with feedback from real conversations across diverse users and use cases. There is simply no substitute for this phase of development.
What would help most:
- Does the memory system store things it shouldn't? Miss things it should catch?
- Does contradiction detection fire when it should — and stay quiet when it shouldn't?
- Does the hybrid memory search surface the right memories for your queries?
- Do ZynkSync and ZynkLink work reliably across your devices and network setup?
v1.0 and mobile development depend on what we learn in this phase. If you have a GitHub account, open an issue. If you'd prefer to contact the project directly, feedback is always welcome at matt@containai.ai.
Installation
Quick Install (Recommended)
Pre-built binaries are available for Android, Linux, and Windows — no compilation required.
Download from GitHub Releases →
| Platform | Package |
|---|---|
| Android | .apk (arm64) |
| Linux | .deb (amd64), .AppImage, or .rpm |
| Windows | .exe installer or .msi |
Android: Download the APK and tap to install. Android will prompt you to allow installation from unknown sources — this is a one-time prompt per device.
Once Zynkbot is on both your phone and desktop, open Settings → ZynkSync on each device and pair them. After that, your memory stays in sync automatically whenever both devices are on the same network.
⚠️ Local models are CPU-only in pre-built desktop binaries. They work but can have 60+ second responses on some hardware. For optimized local model performance with CUDA support, clone and use the developer install below. API models (Claude, GPT-4, Grok) are unaffected. Android uses API models only in Phase 1.
Developer Install (from source)
- Windows Installation Guide — automated installer (
install.bat) with step-by-step instructions - Linux Installation Guide — automated installer (
install.sh) with step-by-step instructions for Ubuntu, Arch, and Fedora
Project Structure
zynkbot/
├── zynkbot_rust/ # Main Rust/Tauri application
│ ├── src/ # React frontend
│ │ ├── App.jsx # Main application shell: chat UI, message routing, streaming, session management
│ │ └── components/ # UI components
│ │ ├── ChatMessage.jsx # Individual message rendering (streaming, web search, memory citations)
│ │ ├── MemoryManagerModal.jsx # View/edit memories
│ │ ├── ConversationHistoryPanel.jsx
│ │ ├── EnsembleModal.jsx
│ │ ├── ConflictResolutionModal.jsx
│ │ ├── KnowledgeBaseManager.jsx
│ │ ├── ZynkSyncPanel.jsx
│ │ ├── ZChatModal.jsx
│ │ ├── MemoryGraphModal.jsx
│ │ └── ... # Settings, onboarding, snap-ins, etc.
│ ├── src-tauri/ # Rust backend
│ │ ├── src/
│ │ │ ├── lib.rs # Tauri entry point: module declarations + invoke_handler registration
│ │ │ ├── commands/ # Tauri IPC command handlers (modular)
│ │ │ │ ├── memory.rs # Memory CRUD, links, graph, contradictions
│ │ │ │ ├── onboarding.rs # Onboarding flow, Einstein demo, system seeding
│ │ │ │ ├── conversation.rs # Session history, feedback, prompt builder
│ │ │ │ ├── nlp.rs # Entity extraction, fact extraction
│ │ │ │ ├── models.rs # API key management, model discovery
│ │ │ │ └── safety.rs # Containment modes, safety classifier
│ │ │ ├── memory.rs # Memory storage, hybrid search, deduplication
│ │ │ ├── conversation_engine.rs # Prompt construction, context assembly
│ │ │ ├── conversation_history.rs # Session logging and history search
│ │ │ ├── containment.rs # Safety layer + containment modes
│ │ │ ├── safety_classifier.rs # TinyBERT toxic-bert inference
│ │ │ ├── web_search.rs # On-demand live web search
│ │ │ ├── kb_rag.rs # Knowledge base RAG retrieval
│ │ │ ├── knowledge_base.rs # KB document management
│ │ │ ├── db.rs # Database connection helpers
│ │ │ ├── user_identity.rs # User & device identity (required for ZynkSync/ZynkLink)
│ │ │ ├── nlp_enhancer.rs # NLP utilities
│ │ │ ├── llm_fact_extractor.rs # Fact extraction helpers
│ │ │ ├── question_extractor.rs # Question detection
│ │ │ ├── sync_codes.rs # ZynkSync pairing codes
│ │ │ ├── zchat.rs # Device-to-device messaging
│ │ │ ├── zynksync.rs # Cross-device memory sync
│ │ │ ├── zynklink.rs # Peer-to-peer file transfer
│ │ │ ├── vosk_desktop.rs # Offline voice dictation (Linux, Vosk)
│ │ │ └── llm/ # LLM backends
│ │ │ ├── local_models.rs # Local .gguf inference
│ │ │ ├── local_embeddings.rs # all-MiniLM-L6-v2 embeddings
│ │ │ ├── anthropic.rs
│ │ │ ├── openai.rs
│ │ │ └── xai.rs
│ │ ├── migrations/ # Database schema (sqlx)
│ │ └── models/ # ML model weights
│ │ ├── system/ # Auto-downloaded: embeddings, NER, safety
│ │ └── user/ # Optional local LLMs (.gguf files)
│ └── system_docs/_system/ # Built-in Zynkbot documentation (auto-indexed at startup)
├── docs/
│ ├── FEATURES.md
│ ├── ROADMAP.md
│ ├── architecture_and_development/DATABASE_SCHEMA.md
│ ├── architecture_and_development/MEMORY_PROCESSING_PIPELINE.md
│ ├── architecture_and_development/PROMPT_CONSTRUCTION_PIPELINE.md
│ ├── NETWORKING_FEATURES.md
│ ├── DIGITAL_RESILIENCE.md
│ ├── INSTALLATION_TROUBLESHOOTING.md
│ ├── LINUX_INSTALLATION_GUIDE.md
│ ├── WINDOWS_INSTALLATION_GUIDE.md
│ ├── case_studies/ # Real-world usage scenarios
│ ├── snap_ins/ # Snap-in catalog and architecture
│ ├── architecture_and_development/ # Internal architecture docs
│ ├── troubleshooting/ # Diagnostic scripts, guides, and known issues
│ └── archive/ # Python prototype (historical)
├── assets/ # Screenshots and images
├── scripts/
│ ├── db/ # Database management scripts
│ └── dev/ # Developer utilities (model download, etc.)
├── labs/ # Research prototypes (MoE POC, snap-in platform, etc.)
├── knowledge_base/ # Default knowledge base content
├── install.bat # Windows installer
├── install.sh # Linux installer
├── START_ZYNKBOT.bat # Windows launcher
├── START_ZYNKBOT.sh # Linux launcher
Architecture
Why Rust
Rust was a constraint, not a preference. Zynkbot has to run on Windows, Linux, and Android with one maintainer, and every platform needs local inference — embeddings, entity extraction, safety classification, and GGUF models all running on-device. Rust is the only stack where every one of those pieces is first-class: Candle for embeddings and NER, llama-cpp-2 for GGUF inference, ONNX for wake-word detection, and Vosk for offline speech. Flutter or React Native would have meant a Rust core behind FFI anyway, plus a second runtime to feed it. Kotlin Multiplatform was the real alternative, and it would have cost the desktop build.
The tradeoff is real: with Tauri, the platform-specific work — foreground services, wake locks, lock-screen behavior — is harder than it would be in a native Android project. That cost is explained here.
As of two years ago, I had no experience with Rust and only an interest. When it became apparent the project required it, it became a learning experience.
┌──────────────────────────────────────────────────────┐
│ Zynkbot — Desktop (Windows/Linux) + Android │
│ ┌────────────────────────────────────────────────┐ │
│ │ React Frontend (Tauri WebView) │ │
│ │ • Chat Interface + Web Search │ │
│ │ • Memory Manager + Conversation History │ │
│ │ • Settings / Containment Mode Selector │ │
│ └──────────────────────┬─────────────────────────┘ │
│ │ Tauri IPC │
│ ↓ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Rust Backend (src-tauri/src/) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Containment Layer (Guardian/Child/HIPAA/...) │ │ ← Local only
│ │ └─ Safety classifier (toxic-bert) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Conversation Engine (prompt construction) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Hybrid Memory Search │ │
│ │ ├─ Entity extraction (bert-base-NER) [1] │ │
│ │ ├─ Semantic similarity (all-MiniLM-L6-v2) │ │
│ │ └─ Weighted scoring (60% entity / 40% sem) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Knowledge Base (RAG) semantic doc search │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Local database + vector search (memory store) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ LLM Backend (configurable, switchable) │ │
│ │ ├─ Local .gguf models (desktop — fully offline│ │ ← Privacy-first
│ │ ├─ Ollama / LM Studio (desktop; Android via │ │
│ │ │ LAN proxy over ZynkSync│ │
│ │ └─ OpenAI / Anthropic / xAI (opt-in API) │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Post-Response Memory Pipeline (background) │ │
│ │ └─ LLM evaluates message, decides what to │ │
│ │ store, generates title and relationship │ │
│ │ graph; surfaces contradictions to user │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ Networking (LAN / WiFi only — no cloud) │ │
│ │ ├─ ZynkSync memory sync across devices │ │
│ │ ├─ ZynkLink peer-to-peer file transfer │ │
│ │ └─ ZChat device-to-device messaging │ │
│ └─────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘
→ Comprehensive Architecture Documentation
[1] Open source contribution: bert-base-NER required implementing BertForTokenClassification in the Candle ML framework — which had no support for token classification (named entity recognition.) The implementation was developed for the Zynkbot project and contributed upstream and is awaiting merge: candle PR #3212. Candle-based inference — embeddings, NER, and safety classification — runs in pure Rust with no Python runtime. Local GGUF chat models use llama.cpp (via llama-cpp-2), which compiles from source during installation; on Windows this requires the Visual Studio C++ Build Tools (see the installation guide).
Memory System
- Semantic Search: Vector similarity search (384-dim embeddings)
- Entity Extraction: BERT NER for precise fact retrieval
- Hybrid Search: Entity + semantic search, combined and weighted
- Transparent Recall: See exactly which memories influenced responses
- Editable: Full control over stored memories via Memory Manager
- Namespace Support: Organize memories by category (personal, work, family)
When a contradiction is detected between two memories, Zynkbot surfaces both and asks you to resolve it — never silently overwrites your data.
Containment Modes
A containment mode is a global safety setting that applies to everything Zynkbot processes — every message in, every response out. Think of it as the safety layer that wraps your entire session. Unlike snap-ins (which are industry-specific behavior customizations), a containment mode is a filter on the AI itself: it determines what kinds of content are allowed through, blocked, or flagged.
Every installation runs in exactly one containment mode at a time. The default is Guardian, which blocks severe harm categories without being overly restrictive for everyday use. Developers can implement new modes for specialized deployment scenarios.
| Mode | Safety Level | Use Case |
|---|---|---|
| Guardian | Moderate (default) | General use, blocks severe harm |
| Child | Strict | For minors, aggressive filtering |
| Sovereign | Warnings only | Warns but doesn't block |
| Witness | No filtering | Full freedom, no restrictions |
| HIPAA | Healthcare-oriented | PHI detection, no memory storage |
How filtering works:
- Guardian / Sovereign / Witness: Local TinyBERT (toxic-bert) model — runs entirely on your device, no data leaves
- Child Mode: OpenAI Moderation API — requires an OpenAI API key for the strictest protection
- HIPAA Mode: Pre-LLM PHI detection (SSN, phone, email, etc.) + audit logging + enforced ephemeral mode (nothing stored)
Networking Features
ZynkSync - Sync memories across YOUR devices (carry conversations across phone/PC/laptop)
ZynkLink - Share files between PAIRED Zynkbots (different users)
ZChat - Direct device-to-device messaging
All features work over your local network (WiFi/LAN/mobile hotspot) with no cloud dependency.
LLM Backends
Local Models (Privacy-First):
- Place
.gguffiles inzynkbot_rust/src-tauri/models/user/ - Recommended: Qwen3 8B, DeepSeek R1 Distill Llama 8B, Llama 3.1 8B Lexi Uncensored V2 — optional download included in installation script
- No API key needed — runs completely offline
- CPU works; NVIDIA GPU with CUDA gives 10–100x faster responses (automatically configured by the installer if you have the CUDA toolkit — see GPU Acceleration below)
Ollama & OpenAI-compatible servers (Free, local):
Ollama runs open-source models locally with no API key or subscription. Install it, pull a model, and point Zynkbot at http://localhost:11434/v1. LM Studio and llama-server work the same way.
Android bonus: if your phone is paired with your desktop via ZynkSync, it can route chat requests through your desktop's Ollama over your home network — no separate setup required. Tap "Connect to Ollama on [PC]" in the Android API settings.
API Models (Optional):
You can connect to any of these cloud providers. Your memory database stays local — only the conversation prompt is sent. Additional API LLMs coming soon.
- Anthropic (Claude models) — Get API key
- OpenAI (GPT and o-series models) — Get API key
Note: Even if you primarily use another provider, an OpenAI key is recommended — it also enables Whisper voice transcription and TTS response dictation.
- xAI (Grok models) — Get API key
- Mistral (Mistral and Codestral models) — Get API key
Wondering what API keys actually cost? → Honest cost estimates
Configure: Settings → API Keys
Switch between any configured backend mid-conversation without losing context.
Ensemble Mode:
Query multiple models simultaneously with the same prompt, then have a coordinator model evaluate all responses and synthesize the best answer. The coordinator doesn't average or vote — it identifies where models agree (treated as higher confidence), where they disagree (the better-supported position is chosen or the claim is marked uncertain), and where one model adds something the others missed. No fact can appear in the synthesized answer that wasn't independently produced by at least one of the queried models.
The coordinator is automatically selected from whatever models you have configured, preferring the highest-capability one available (Claude → Grok → GPT → local).
Where this helps:
- Fact-checking technical claims — version numbers, API names, and specific details that models frequently hallucinate are flagged when models disagree, rather than silently accepted
- Contested or nuanced questions — disagreement between models is surfaced explicitly, so you know when a question has no clear consensus answer
- Reducing false confidence — the coordinator is itself an LLM and can hallucinate. LLMs are most likely to hallucinate on recent, specific data — version numbers, release dates, named products — and multiple models can converge on the same wrong answer when they've all learned from the same sources. The coordinator is explicitly instructed to account for these factors and flag uncertainty rather than treat consensus as proof
GPU Acceleration
If you have an NVIDIA GPU, the installation script automatically enables CUDA so local models run 10–100x faster — no manual configuration needed.
What the installer does:
- Detects your GPU via
nvidia-smi - If the CUDA toolkit (
nvcc) is also present,START_ZYNKBOT.sh/START_ZYNKBOT.batpasses--features cudato the Rust compiler at build time — no files are modified - If only the GPU is found (no toolkit), it prints instructions and builds CPU-only
If the installer built CPU-only and you want GPU acceleration:
Install the CUDA toolkit, then uninstall and re-install install.sh (Linux) or install.bat (Windows):
| Platform | Command |
|---|---|
| Ubuntu/Debian | sudo apt install nvidia-cuda-toolkit |
| Fedora | sudo dnf install cuda-toolkit |
| Arch | sudo pacman -S cuda |
| Windows / all | NVIDIA CUDA Downloads |
The installer does not install the CUDA toolkit itself — that requires a reboot and is distro-specific. Everything else is handled automatically.
System Requirements
Minimum:
- Windows 10/11 (64-bit) or Linux (Ubuntu 22.04+, Arch, Fedora)
- 8 GB RAM
- 10 GB free disk space (Zynkbot + 1 or 2 local models)
- Internet connection (for installation only)
Recommended:
- 16 GB RAM
- 30 GB free disk space (for additional local models)
- SSD for better performance
- NVIDIA GPU with CUDA (optional, for faster local LLM inference)
Troubleshooting
Common Issues:
- Database won't start: See Troubleshooting Guide
- Models not loading: See Model Issues
- Build errors: See Compilation Errors
- Networking problems: See Networking Issues
- Windows Defender blocking: Run
docs/troubleshooting/FIX_WINDOWS_DEFENDER.batas Administrator
→ Complete Troubleshooting Guide
Use Cases
Personal:
- Private AI assistant (no cloud tracking)
- Long-term conversational companion
- Memory-augmented productivity tool
Professional:
- Healthcare (local deployment with PHI-aware configuration; not a substitute for HIPAA compliance review)
- Legal (confidential client information)
- Research (proprietary data analysis)
Organizations & Communities:
- Schools, nonprofits, and civic organizations
- Research institutions (proprietary data stays local)
- Humanitarian and emergency response (offline-capable)
- Journalism and advocacy (source protection)
Contributing
Zynkbot is in active development. Contributions welcome!
We need two kinds of contributors:
Builders — if you write Rust, React, or have experience with ML or databases:
- Rust/Tauri feature development
- Performance optimization
- Cross-platform testing (macOS, mobile)
- Test coverage
- Documentation improvements
Zynkbot is written in Rust, but the architecture — local-first memory, hybrid search, containment modes, snap-ins — is language-agnostic. Noncommercial forks and adaptations are welcome under the community source license. Commercial products and services require a separate license.
Before contributing code:
- Review Architecture Documentation
- Run
cargo testinzynkbot_rust/src-tauri/ - Check open issues on GitHub
Companion testers — if you want to use Zynkbot as an actual AI companion:
This is just as important as code contributions. The only way to know whether the memory system works as intended — whether Zynkbot is genuinely getting to know you over time — is to have real people use it that way. If you're willing to use Zynkbot as your primary AI assistant for weeks or months and report back on what works and what doesn't, that's invaluable. Does it remember the right things? Does it surface context at the right moments? Does the memory system feel like it understands you, or just like a database lookup? I haven't had the opportunity to use it the way that it is meant to be used: consistently over months as a real companion. That's what version 0.9 is for. I'm starting this experiment alongside anyone else who decides to install it.
If you're interested in being a companion tester, open an issue on GitHub or email matt@containai.ai.
Support Development
Zynkbot is developed and maintained by one person. If it's useful to you, sponsoring development helps keep it going.
Acknowledgments
Beta Testers & Contributors
Zynkbot is maintained by one person, which means the difference between "works on my machine" and "works" is entirely down to people willing to run it on their own hardware and report back honestly.
- Mike G. (@galbicka) — Extensive beta testing across Windows and Linux, including CUDA/GPU acceleration debugging, ZynkLink and knowledge-base issue reports, and ongoing feedback that's directly shaped v0.9.x stability fixes
This is unglamorous work: reinstalling from scratch, reproducing intermittent failures, and describing them precisely enough to act on. Several fixes in the v0.9.x line exist only because a tester noticed something the developer's own machine was configured to hide.
If you've tested Zynkbot and aren't listed here, open an issue or email matt@containai.ai — the omission is an oversight, not a judgment.
AI Development Tools
Zynkbot was built through a years-long collaboration between its developer and AI coding assistants — beginning with ChatGPT designing Zynkbot as a server-side app in Python with a hosted database in the project's earliest days, then transitioning over time to a fully local Rust port with an embedded SQLite database with help from Claude Code from Anthropic — whose capabilities proved indispensable to bringing the project to completion. The developer gratefully acknowledges both the AI tools and the teams at OpenAI and Anthropic whose work made this possible.
License
Zynkbot's source code is publicly available. It is free for personal, internal business, nonprofit, educational, research, humanitarian, and other noncommercial use.
Commercial distribution and commercial services — including paid installation, hosting, support, hardware bundling, white-labeling, and commercial SDK integration — require a separate commercial license.
Commercial terms may include per-installation pricing, subscriptions, annual renewals, or revenue sharing. Contact matt@containai.ai.
See LICENSE for complete terms and COMMERCIAL_LICENSE.md for commercial licensing information.
Contributing
Contributions require agreement to the Contributor License Agreement. You keep copyright in your work and grant the project the right to relicense it, which allows commercial licenses to be offered alongside the community source license.
Trademark: "Zynkbot" and "ContainAI" are trademarks of Matthew Skillman — see TRADEMARK.
Copyright (c) 2024-2026 Matthew Skillman / ContainAI
Documentation
- Features Guide - Complete feature documentation
- Roadmap - Planned features and development timeline
- Digital Resilience - Offline-first AI for critical infrastructure, humanitarian deployments, and disaster response
- Networking Features - ZynkSync, ZynkLink, ZChat
- Troubleshooting - Common issues and solutions
- Installation Guides - Platform-specific setup instructions
- Model Architecture - System design and ML pipeline
- Memory Processing Pipeline - How memory search and storage works
- Memory Relationship Graph - The graph visualization: what it shows, practical uses, and research potential
- Prompt Construction Pipeline - How prompts are assembled
- Database Schema - Database structure
- Models - Model information and management
Links
- GitHub: https://github.com/MSkill1/zynkbot
- Documentation: docs/
- Installation:
Status: Feature-complete v0.9, open beta (July 2026) Platform: Windows 10+, Linux (Ubuntu 22.04+, Arch, Fedora), Android Mobile: Android beta available (see Releases); iOS planned Organization: ContainAI – Ethical AI infrastructure Created: 2024-2026 Maintained: Matthew Skillman
Memory without surveillance. Intelligence without manipulation.