Skip to content
kazma.
Search Kazma Documentation & Site
عGet started
Features

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.

  • 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
    Shipped
  • 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

    Opt-in
  • 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
    Shipped
  • Explicit English/Arabic one-paragraph prose and verbatim supplied-JSON output safeguards

    conservative prose layout and literal JSON copies only; no general format guarantee

    Partial
  • 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
    Shipped
  • 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
    Opt-in
  • 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
    Shipped
  • Live two-way voice in the browser through LiveKit

    LIVEKIT_URL and keys

    Opt-in
  • 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
    Shipped

Models

Bring the model you trust — a cloud provider, or one that runs on your own machine.

  • 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
    Shipped

Safety and control

Nothing risky happens without you, and untrusted text is treated as data.

  • Dangerous actions wait for your approval — on chat, multi-agent and pipeline paths alike; unclassified tools are gated by default

    Where: Threat modelDocs
    Shipped
  • 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

    Partial
  • 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
    Shipped
  • 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

    Partial
  • Code the agent runs in an isolated container

    Docker (KAZMA_CODE_EXEC_DOCKER=force) or E2B

    Where: tools/code_exec.py
    Opt-in

Memory

It remembers what matters, shows you what it used, and forgets what you tell it to.

  • 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
    Shipped
  • Shared memory between installs through Postgres

    memories and facts mirror; each install keeps its own vectors and graph

    Partial
  • 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
    Shipped

Knowledge and documents

Give it your files and sites; it reads, searches, converts and writes documents — Arabic included.

  • 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
    Shipped
  • 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
    Partial
  • Virus scanning of uploads

    needs ClamAV installed; with KAZMA_PRODUCTION=1 an upload is refused until a scan can run

    Where: documents/malware.py
    Opt-in
  • 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
    Shipped
  • 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
    Partial
  • 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
    Opt-in
  • 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

    Shipped
  • 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

    Partial
  • 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
    Shipped
  • 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

    Partial
  • 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

    Shipped
  • Scraping through a rotating residential proxy

    allowed by name in the web acquisition settings, then set up in Settings

    Where: Settings → System → Proxy
    Opt-in
  • Image generation (Pollinations with no key; DALL-E, Stability, Flux with keys) and image understanding

    Where: tools/image_gen.py
    Shipped

Work on code

An editor, git and GitHub — and every write goes through your approval.

  • 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
    Shipped

Many agents at once

Split a job across workers that are created when needed and watched while they run.

  • 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
    Shipped
  • Durable multi-step runs through Temporal

    Where: swarm/durable_temporal.py
    Opt-in

How the six patterns flow

Six ways to split work across workers — pick one to see how it flows.

Dynamic Autoscaling Enabled

Fan-Out & Voting

Parallel Consensus
Topology: 1 → [3 Parallel] → 1

Dispatches identical or partitioned tasks across multiple isolated workers simultaneously, aggregating outputs via weighted voting or consensus deduplication.

Execution Flow Nodes

SupervisorWorker Alpha (Coder)Worker Beta (Tester)Worker Gamma (Security)Consensus Aggregator
Recommended for: Complex audits, competitive code synthesis, and high-assurance verification.

Automation and connected accounts

Mail, calendars, reminders and posts — handled in the chat where you asked.

  • 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
    Shipped

Running it

Built to be run for months: it restarts itself, backs itself up, and tells you what happened.

  • A supervisor that restarts on real failure, reloads gracefully and pages you over Telegram

    Where: scripts/service/kazma_guard.py
    Shipped
  • 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
    Opt-in
  • 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
  • Prometheus metrics; OpenTelemetry and Langfuse traces

    Where: /metricsDocs
    Shipped / Opt-in
  • 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
    Partial
  • 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
    Shipped
  • 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

    Partial
  • 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
    Opt-in

Trust you can check

Signed releases, continuous checks and public scores — evidence, not promises.

  • 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

    Shipped

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.