Everything Kazma does.
118 features in 10 areas, every line checked against the code and marked with its status. What isn't built yet is listed at the end.
Source:docs/FEATURES.md, updated 17 November 2026.
What the statuses mean
- Shipped
- works out of the box or one setting away
- Opt-in
- works once you install or configure the named extra
- Partial
- works, with the limit stated
- Not built
- people ask; it is not there
One assistant, everywhere you talk to it
The same assistant, the same memory and the same approvals in the browser, the terminal and your chat apps.
- Shipped
Web chat with streaming answers, a step-by-step activity view per answer, and approvals inline
Where: /chatDocs - Shipped
Telegram, Discord and Slack: text, photos and documents, voice notes transcribed, approve/deny buttons, per-platform allowed-user lists
Where: kazma-gatewayDocs - Opt-in
WhatsApp, through Meta's WhatsApp Cloud API: text, photos, documents, voice notes, approve/deny buttons, allowed numbers; Meta's signature checked on every call
your own Meta app, number and token; Meta allows a reply only within 24 hours of your last message; live on a real business number since 2026-11-16
Where: Settings → Providers & Connectors → Platform Connectors → WhatsAppDocs - Opt-in
Native Telegram command menus and Discord/Slack /kazma commands
external application registration is required; private continuation credentials expire on restart
- Shipped
Each chat app's Test diagnoses the connection: the token, the chat or channel Kazma delivers to, direct messages, allowed users, and what became of the last message a person sent
Where: Settings → Providers & Connectors → Platform ConnectorsDocs - Shipped
Finalized chat replies delivered without gateway tone rewriting, with one terminal persistence owner
- Shipped
Tables in an answer are rewritten as lines for Telegram, Discord and Slack, so they read on a phone
Where: kazma_gateway/chat_tables.py - Partial
Explicit English/Arabic one-paragraph prose and verbatim supplied-JSON output safeguards
conservative prose layout and literal JSON copies only; no general format guarantee
- Shipped
Terminal UI, including a file editor
Where: kazma-tuiDocs - Shipped
Command line: one-shot questions (kazma ask), and the Agent Client Protocol for editors (kazma acp)
Where: kazma-cliDocs - Shipped
An MCP server: other agents can use Kazma's tools, with the same approval gate (kazma mcp)
Where: kazma mcpDocs - Opt-in
Other AI agents can call Kazma over A2A (agent to agent), signed in with one of your API tokens; Kazma only reads for them (web, Knowledge Library, memory) and nothing they ask is remembered
off until switched on
Where: Settings → System → Agent-to-agentDocs - Shipped
Install Kazma as an app on a computer or phone (its own window and icon); while Kazma restarts the app shows a page that tries again by itself
browsers install only from https or this computer
Where: the browser's "Install app" / "Add to Home Screen"Docs - Shipped
Spoken replies (text-to-speech) and speech input; click-to-play in web chat
Where: Settings → VoiceDocs - Opt-in
- Shipped
English and Arabic interface, full right-to-left layout; your words, the model's replies, names and server diagnostics are shown as written, each paragraph in its own language's direction (English left to right, Arabic right to left) in either interface
Where: Every page, the login page includedDocs
Models
Bring the model you trust — a cloud provider, or one that runs on your own machine.
- Shipped
35 providers in one list: OpenAI, Anthropic, Google Gemini (AI Studio or Vertex), DeepSeek, xAI, Mistral, Cohere, Z.AI, Moonshot (Kimi), MiniMax, Qwen, Perplexity, AI21, OpenRouter, Groq, Cerebras, Together, Fireworks, DeepInfra, Hugging Face, NVIDIA, SambaNova, SiliconFlow, Novita, Hyperbolic, Cloudflare Workers AI, Azure OpenAI and AWS Bedrock (each with its own Settings form), Ollama, LM Studio, vLLM, llama.cpp, LocalAI, Jan, and any OpenAI-compatible endpoint, with headers of its own
Where: Settings → ProvidersDocs - Shipped
Each model's context window, output limit, image and tool support and price, from your value, the provider's own model list or Kazma's catalog
Where: Settings → Providers & Connectors → ModelsDocs - Shipped
A model per chat: models named provider:model, and the chat's picker and /model in a chat app change that chat only; one default for the rest
Where: Chat picker, /model, SettingsDocs - Shipped
Several keys per provider: a refused, spent or rate-limited key gives way to the next, and you are told; providers checked hourly in the background
Where: Settings → Providers → AdvancedDocs - Shipped
Local models through Ollama and LM Studio, and any OpenAI-compatible model server on your own network (vLLM, llama.cpp, LocalAI...), with no key
Where: Settings → Providers, the setup guideDocs - Shipped
A provider's Test sends a real message through the same client chat uses, before anything is saved
Where: Settings → ProvidersDocs - Shipped
The backup model is checked: Settings shows which provider would answer it, refuses one nothing serves, and suggests working ones
Where: Settings → System → Non-stopDocs - Shipped
Best model per task for multi-agent workers; image questions go to a vision-capable model
Where: models/selection.py - Shipped
When a model fails over to another, you are told (page + banner)
Where: observability/model_fallback.py - Shipped
Token and cost per answer, each cost the model's own price or shown as unknown (you can set a model's price); a cost breaker that halts runaway spending
Where: Chat footer, dashboard, Settings → Providers & Connectors → Models → Model pricesDocs
Safety and control
Nothing risky happens without you, and untrusted text is treated as data.
- Shipped
Dangerous actions wait for your approval — on chat, multi-agent and pipeline paths alike; unclassified tools are gated by default
Where: Threat modelDocs - Partial
Durable mutation receipts and keyed IDE retries that hold uncertain outcomes for inspection
shared graph, IDE and swarm executors; external or custom effects are not atomic
- Shipped
Plans checked against memory before they act: a reminder date is anchored to what you said, not what the model guessed; catastrophic shell commands are refused before the approval card
Where: Commitment layerDocs - Shipped
Web pages, search results, documents and recalled memory are fenced as untrusted data; the effect is measured on a public benchmark
Where: Prompt injection: the numbersDocs - Shipped
Secrets in an encrypted vault (AES-256-GCM); never passed to programs a tool starts; masked on every screen and API
Where: security/vault.py - Shipped
Protections against server-side request forgery, cross-site requests, and request floods
Where: security/ssrf.py, csrf.py, rate_limit.py - Shipped
Login by secret, local users or OIDC single sign-on; admin, operator and viewer roles
Where: /loginDocs - Partial
Several users or teams on one install
built for one trusted operator; multi-user separation is enforced for memory and chats, not audited end to end
- Opt-in
Code the agent runs in an isolated container
Docker (KAZMA_CODE_EXEC_DOCKER=force) or E2B
Where: tools/code_exec.py
Memory
It remembers what matters, shows you what it used, and forgets what you tell it to.
- Shipped
Remembers conversations and the facts in them, across chats, with when each fact became true
Where: MemoryDocs - Shipped
Recall by evidence: a memory is used only when it matches the question well enough — nothing when nothing does
Where: memory/recall.py - Shipped
Every answer shows which memories it used
Where: Chat activity: "Memory used" - Shipped
"About me": a short text you write, read at the start of every reply
Where: Settings → Memory - Shipped
Bring your history: a ChatGPT or Claude export imported into memory, each turn at its own date
no facts are extracted from it
Where: Memory page → Bring your history, kazma importDocs - Shipped
Weekly topic summaries of long threads
Where: Memory page - Shipped
Forget one memory or a whole chat, from the page or by asking in chat ("forget everything that mentions X" reaches every memory holding it); keep a chat out of memory; export everything
Where: Chat menu → Memory…, Memory page, memory_forget_mentions - Shipped
Works in Arabic and English, Gulf dialect included
Where: memory/query_terms.py - Shipped
Nothing lost by accident: archiving never erases a memory's text
Where: memory/macro_sleep.py - Partial
Shared memory between installs through Postgres
memories and facts mirror; each install keeps its own vectors and graph
- Shipped
A copy of the memory graph in Neo4j (installed with Express on Windows and Linux), kept in step with Kazma's own store: a fact written, changed or forgotten while Neo4j was away reaches it at the next pass; edges Kazma did not write are never touched; Neo4j sends no usage data
Where: Settings → MemoryDocs
Knowledge and documents
Give it your files and sites; it reads, searches, converts and writes documents — Arabic included.
- Shipped
Knowledge Library: add files, web pages or whole sites; search by keywords and by meaning; Arabic-aware
Where: /knowledgeDocs - Shipped
Knowledge crawls that run for hours: the browser is renewed between pages, a site that keeps refusing stops the crawl (Resume continues it), a refresh removes pages the site removed (gone at once, not found confirmed an hour later), and each text is stored once
- Shipped
Documents: upload into quarantine with file-type checks; macro-enabled Office files and PDFs with scripts, outside actions, attachments or links to files and network shares are refused; text from PDF, Word, Excel, PowerPoint, HTML, Markdown, CSV and plain text, Arabic included (legacy .doc/.xls/.ppt through LibreOffice)
Where: /documentsDocs - Partial
OCR of scanned PDFs and images, Arabic and Arabic-Indic digits included; ruled tables on a scanned page read cell by cell
Arabic is read by the neural engine (ONNX Runtime; its models installed by scripts/ocr_models.py install, and built into the document worker image); without them Tesseract reads, and it does not read Arabic-Indic digits. Every OCR case of Kazma's measured corpus qualifies with the neural engine; it is measured on one real scan so far
Where: documents/ocr/Docs - Opt-in
Virus scanning of uploads
needs ClamAV installed; with KAZMA_PRODUCTION=1 an upload is refused until a scan can run
Where: documents/malware.py - Shipped
Convert, split, merge and redact documents; generate reports as Word, PDF or HTML in one house style, with correct Arabic typography and each paragraph and table in its own language's direction
full-quality Arabic PDFs need LibreOffice; without it a limited fallback, with a warning
Where: /documentsDocs - Shipped
Pictures in generated Word, PDF and PowerPoint files: placed where the text names them, with a caption, beside a slide's text; each decoded and saved again in the document worker first, with its location data and other metadata dropped; a picture on the web saved first with download_image
PNG, JPEG, GIF and WebP; 40 pictures, 20 MB each
Where: documents/image_clean.pyDocs - Partial
Untrusted documents parsed in a separate worker with memory and CPU limits; optionally one container per job, with no network and no mounts
the default worker does not confine files or network and is not qualified for hostile documents; the container profile is a Settings choice that needs Docker, and the guard runs its broker
Where: KAZMA_DOCUMENT_WORKER_ISOLATIONDocs - Partial
Durable document jobs: limits answered before an upload is read, outages retried, interrupted uploads rolled back after a crash, a Postgres document store backed up as one point in time
a 48-hour soak passed on the default process profile with SQLite stores, with no errors; not soaked on the container profile or on Postgres, and multi-replica is not qualified. An independent security review found one issue, fixed and confirmed by the reviewer
Where: /documentsDocs - Opt-in
A hard PDF sent to a third-party parser (LlamaParse, Reducto) when local extraction is weak
off by default; every upload is audited first
Where: documents.security.remote_parseDocs - Shipped
Deep web research with sources: search, read, crawl, summarize
Where: /researchDocs - Shipped
Web search through SearXNG (self-hosted metasearch, installed with Express on Windows and Linux)
Where: tools/web_search.py - Shipped
PDFs on the web (theses, articles, reports) read as their text layer by the sandboxed document worker, in chat and in research
up to 20 MB, no OCR on a web read (a scan is refused); Knowledge crawls leave PDFs out
- Shipped
Search falls back to Bing, then Wikipedia's full-text search, when an engine answers with nothing or with results not about the query
an answer counts only when at least half its results hold a word of the query
- Partial
Web pages are read on your own machine: fetched directly, or rendered in a local browser when they need JavaScript; hosted reading services (Firecrawl, Jina) are used only if you allow them
the fully network-isolated browser needs Linux; on Windows the browser runs in a less isolated mode, not yet qualified for very long runs
- Shipped
Research and crawls survive a restart: every step is recorded, and an interrupted run continues where it stopped
the storage for runs and reports is capped; a step whose outcome is unknown is never repeated by itself
- Shipped
An alert when research or a crawl finishes, linking to its saved results, and a warning when one stalls, recovers or ends early
on by default; alerts reach your chat apps once an alert route is set
Where: Settings → System → Web acquisitionDocs - Partial
What each paid web service used, its errors and its balance, in the web page, chat, command line and terminal app
a balance or charge a service does not report is shown as unknown; a balance is refreshed only when you ask
- Shipped
Crawls and research respect each site's robots.txt and pace their requests to every site
a site whose robots.txt cannot be read is not crawled; switching the check off is shown
- Opt-in
Scraping through a rotating residential proxy
allowed by name in the web acquisition settings, then set up in Settings
Where: Settings → System → Proxy - Shipped
Image generation (Pollinations with no key; DALL-E, Stability, Flux with keys) and image understanding
Where: tools/image_gen.py
Work on code
An editor, git and GitHub — and every write goes through your approval.
- Shipped
Web IDE: browse, edit, patch, run, git — every write through the approval gate
Where: /ideDocs - Shipped
Clone and switch repositories; the agent always works in the active one
Where: /workspace - Shipped
GitHub: branches, commits, pull requests and issues, through a GitHub App or a token; read-only history and diffs (git_log, git_diff) need no approval
Where: git_github_manager skill - Shipped
Code search across the repository (ripgrep plus symbols)
Where: kazma_core/code_index - Shipped
Steer a running task (/steer), abort it, plan first (/plan), long missions (/long)
Where: Chat commandsDocs - Shipped
Rewind or branch a conversation from any earlier step
Where: /replay, /forkDocs
Many agents at once
Split a job across workers that are created when needed and watched while they run.
- Shipped
Six ways to run workers: dispatch, broadcast, pipeline (with approval checkpoints), fan-out with voting, consult, conditional
Where: /swarm, kazma swarmDocs - Shipped
Workers created on demand from templates — none need registering first
Where: swarm/autoscaler.py - Shipped
Circuit breakers, retries, timeouts and output checks per worker
Where: swarm/reliability.py - Opt-in
Durable multi-step runs through Temporal
Where: swarm/durable_temporal.py
How the six patterns flow
Six ways to split work across workers — pick one to see how it flows.
Fan-Out & Voting
Parallel ConsensusDispatches identical or partitioned tasks across multiple isolated workers simultaneously, aggregating outputs via weighted voting or consensus deduplication.
Execution Flow Nodes
Automation and connected accounts
Mail, calendars, reminders and posts — handled in the chat where you asked.
- Shipped
Reminders and scheduled tasks, delivered to the chat you asked from
Where: /scheduled - Shipped
Ready-made automations in one click: a morning briefing, inbox triage, a weekly report, a news digest; each only reads
Where: /scheduledDocs - Shipped
X (Twitter): drafts, schedule, post through the official API, reply to mentions
Where: /xDocs - Shipped
The whole X API through the official API: every operation of X's own spec found, read or done (search, followers, likes, lists, bookmarks, direct messages, Spaces, streams...), each write asked on a card that names it; photos, GIFs and videos on posts; the app's Bearer token and Sign in with X (OAuth 2.0) besides the four keys
Where: Settings → X; x_api_operations, x_api_read, x_api_act, x_upload_mediaDocs - Shipped
X subject setup, scoped Support/Against, reply language and optional profanity; previews and model compatibility tests
Where: Settings → X; /x ConversationsDocs - Shipped
X posts drafted from your brief and up to three reference documents you name (for example the page describing Kazma), in X Studio or by asking in chat; each draft is fact-checked against them and saved for review, never sent; posts have their own length setting
Where: Settings → X → Reference documents and Post length; /x Composer; x_draft_postsDocs - Shipped
Email (Gmail, Outlook) and calendar (Google, Microsoft)
Where: Settings → EmailDocs - Shipped
More than one mail account (several Gmail, Outlook or IMAP), each with its own calendar, named in chat by name or address
Where: Settings → Email → Other accountsDocs - Shipped
Skills from the open agentskills.io ecosystem: search, install from GitHub, signed and verified
Where: /skillsDocs - Shipped
MCP tools from any MCP server (stdio, SSE, streamable HTTP)
Where: /mcpDocs
Running it
Built to be run for months: it restarts itself, backs itself up, and tells you what happened.
- Shipped
A supervisor that restarts on real failure, reloads gracefully and pages you over Telegram
Where: scripts/service/kazma_guard.py - Opt-in
Kazma Watch: a watcher outside the computer, on your own Cloudflare account, that tells you on Telegram when the machine, the tunnel or Kazma stops answering; set up in one command
a free Cloudflare account and a Telegram bot
Where: kazma observer setupDocs - Shipped
Report a problem from anywhere: you see the whole report first, and it holds nothing private (a chat only if you tick it)
Where: the ? beside the bell, kazma report, /reportDocs - Shipped
The port of Kazma's page chosen at install (9090 by default) and changed later with one command; the supervisor and every kazma command follow it
Where: kazma setup portDocs - Shipped
On Windows, Kazma installs its own container engine (Docker as a service in a WSL distro of its own), which starts at boot with nobody signed in; Docker Desktop stays a choice
Where: kazma setup engineDocs - Shipped
An install whose containers run on Docker Desktop moves them to Kazma's engine in one command: only Kazma's own, their data checked file by file, and everything put back if a step fails
Where: kazma setup engine --move-from-desktopDocs - Shipped
Kazma's container engine stops its containers cleanly when Windows shuts down or restarts, so nothing they just wrote is lost
Where: kazma setup engineDocs - Shipped
When an update leaves Docker stopped, the supervisor starts it again (Kazma's own engine or Docker Desktop) and then the stopped containers Kazma uses (never another project's)
Where: kazma_guard.py --statusDocs - Shipped
One status card per restart: how long Kazma was down and whether each chat app connected (start and stop messages are optional)
Where: Settings → Alerts → Server status messagesDocs - Shipped
Backups of everything every 6 hours, snapshotted locally and offsite (restic), checked daily, with a weekly restore rehearsal of the database; a zip copy to a cloud provider that keeps only the newest N copies
Where: Disaster recoveryDocs - Shipped
Move an install to another machine or OS in one bundle
Where: kazma migrateDocs - Shipped
Back up your settings to a file and restore them: you see what will change first, the keys you have are never replaced, a lost key comes back from the vault without typing it, and the restore can be undone
Where: Settings → SystemDocs - Shipped
Health checks that make a real round trip; alerts to Telegram, Discord or Slack; a daily digest and a weekly resilience report
Where: /health/deep - Shipped
A daily check crawls one known page for real and renders it in Kazma's own browser; a failure is an alert the same day
Where: Settings → System → Web acquisition - Shipped
Old chat step history pruned on a schedule you set
Where: Settings → System - Shipped
Every task Kazma runs is watched (chat turns, swarm tasks, scheduled jobs, documents, research and crawls, X posts, memory, maintenance): when one stalls, gets stuck or fails, a card in the chat it started from offers Retry, Cancel, Dismiss or Ask Kazma to diagnose; one optional automatic first step
Where: Running work, /runsDocs - Shipped
Postgres for settings, chats, tasks and checkpoints; SQLite with no setup
Where: PostgresDocs - Shipped
Admin answer-quality signals without storing answer text in the signal record
- Shipped / Opt-in
Prometheus metrics; OpenTelemetry and Langfuse traces
Where: /metricsDocs - Partial
A Windows installer: no git and no terminal; it installs a release and runs the same setup, and kazma update keeps it current from each release's signed source
from the release after 0.21.2; Windows shows a SmartScreen warning until the installer is signed
Where: kazma-<version>-windows-setup.exeDocs - Shipped
Updates in one command: on a supervised install it waits for the chats to go quiet, stops Kazma, installs and starts it again
Where: kazma updateDocs - Shipped
Updates install the package versions Kazma was tested with, and every release is tested as an upgrade from the one before
Where: kazma updateDocs - Shipped
Uninstall: takes off what setup put on; your data is kept unless you ask, and then moved aside (Kazma's database backed up first)
Where: kazma uninstallDocs - Shipped
A Postgres install moves to a new major version in one command, put back if a step fails
Where: kazma setup postgres --upgradeDocs - Partial
Active-passive recovery preparation with one active runtime owner, fencing and paired backups
target-cluster drills are required; shared Postgres alone does not qualify concurrent runtimes
- Opt-in
Fault injection to test retries and failover: slow or failing model calls, tool calls and reply saves (other targets have no injection point yet); off unless enabled
Where: KAZMA_CHAOS_ENABLEDDocs
Trust you can check
Signed releases, continuous checks and public scores — evidence, not promises.
- Shipped
Every release signed with Sigstore, with build provenance (SLSA) and a list of everything inside it (SBOM); kazma update installs only a release whose signature holds
from 0.21.2 on
- Shipped
Installs and updates use the exact package versions Kazma was tested with, each checked by its hash
Where: kazma updateDocs - Shipped
Checked on every change: CodeQL and SonarCloud code scanning, fuzzing of the code that reads outside text, and the test suite's coverage published on Codecov
Where: the README's badgesDocs - Shipped
OpenSSF Best Practices passing badge (100%) and an OpenSSF Scorecard published weekly
Where: bestpractices.devDocs - Shipped
A defensive security review of the whole code base, every gap it found fixed with a test
2026-11-15; the independent outside review is still to come
Not built
People ask for these; they aren't there. Listed so you don't have to look.
- Not built
A paid bug bounty (responsible disclosure only — SECURITY.md).
- Not built
Cryptographic trust tiers for skills beyond HMAC verification, and signed delegation between agents.
- Not built
A security self-check at every start: the hardening report runs only when you ask for it.
- Not built
A security audit of multi-tenant, internet-facing deployments. Kazma is built for one trusted operator.

