Revka documentation

Revka is a Rust-first, audit-first AI agent workflow platform. It ships as a single revka binary that embeds a web dashboard, a REST + WebSocket gateway, a cron scheduler, a channel supervisor, and a full CLI — all backed by Kumiho graph memory. You run one process, point it at a model provider, and you have a governed agent you can talk to from chat channels, drive from the command line, or orchestrate through declarative workflows.

These docs cover everything Revka exposes: installation and onboarding, the core concepts, the dashboard, the gateway API, channels, providers, tools, memory, workflows, cron, security, deployment, hardware, the MCP/extensibility surface, and the configuration reference. If you are new, start with Installation and Quickstart; if you are integrating, jump to the Gateway API; if you are operating a deployment, head to Deploy.

Install Revka Get the revka binary running on macOS, Linux, Windows, or in a container.

Quickstart Onboard a provider, start the gateway, and talk to your first agent.

What is Revka

Revka turns a language model into a long-running, governed agent. A single host process runs the agent loop, serves a dashboard and API, supervises chat channels, fires scheduled jobs, and persists memory — so the same agent is reachable from Telegram, a browser, the CLI, an IDE, or another agent over the A2A protocol.

Rust-first runtime

The runtime is 100% Rust and deploys everywhere from a Raspberry Pi to a production cloud cluster. The same binary runs as a foreground session, gateway-only server, autonomous daemon, OS service, or container.

Memory-native

Built on Kumiho versioned graph memory. Agents recall context before responding and reflect captures with provenance edges after — so knowledge, decisions, and skills carry across sessions.

Gateway + dashboard

A REST + SSE + WebSocket gateway and an embedded React dashboard for workflows, agents, memory, cron, cost, audit, and config — all from one URL.

Audit-first by design

Approvals, emergency stop, OTP gating, command policy, and runtime tracing are part of the core, not bolted on after the fact.

Single-binary architecture

The revka binary embeds every runtime component, so a single process is all you need to go from install to a working agent. The components are:

• Agent loop — the model-driven reasoning, tool-call, and response cycle.
• Gateway — the REST API, Server-Sent Events stream, and WebSocket endpoints, plus the embedded React/TypeScript dashboard.
• Channel supervisor — connects and restarts chat channels (Telegram, Discord, Slack, Matrix, and more) under exponential-backoff supervision.
• Cron scheduler — persistent scheduled jobs for agent tasks.
• Heartbeat — optional interval-driven, LLM-backed check-in tasks.
• Kumiho memory — graph-backed recall and capture via a Python MCP sidecar.

revka gateway starts just the dashboard and API. revka daemon runs the full runtime — gateway, all configured channels, heartbeat, and the cron scheduler — as one supervised process.

revka gateway        # dashboard + REST/SSE/WebSocket API only
revka daemon         # full runtime: gateway + channels + heartbeat + cron

By default the gateway binds to http://127.0.0.1:42617 (localhost only). Binding to a non-loopback address requires gateway.allow_public_bind = true.

[gateway]
host = "127.0.0.1"   # 0.0.0.0 / [::] for LAN — needs allow_public_bind
port = 42617
allow_public_bind = false

A few endpoints are useful from the very first run:

curl http://127.0.0.1:42617/health      # liveness probe
revka status                            # daemon/component status
revka status --format=exit-code         # 0 = healthy (used by Docker HEALTHCHECK)

Tip

The runtime auto-provisions its Python MCP sidecars (Kumiho and Operator) into isolated per-sidecar virtual environments the first time you start an agent or daemon. See Install the Python MCP sidecars.

The dashboard

The gateway embeds an 18-route React dashboard served from the same address. Open it in a browser once the gateway is running:

http://127.0.0.1:42617

The pages group into orchestration, operations, and inspection surfaces:

• Orchestration — Dashboard, Workflows, Runs, Teams, Canvas, Agents.
• Operations — Cron, Cost, Config, Skills, Tools, Integrations, Skins.
• Inspection — Memory, Assets, Logs, Audit, Doctor, Pairing.

If the gateway requires pairing, the dashboard prompts for a pair code. Generate one from the CLI:

revka gateway get-paircode          # show the current pair code
revka gateway get-paircode --new    # rotate it

See the Dashboard overview for a tour of each page, and Run the dashboard to get it up locally.

Memory-native runtime

Revka has two layers of memory. Local memory stores agent entries you can inspect and manage from the CLI:

revka memory stats
revka memory list [--category NAME] [--session ID]
revka memory get KEY
revka memory clear [--key KEY] [--category CATEGORY] [--yes]

Kumiho graph memory is the persistent, versioned graph that gives agents continuity. It uses a two-reflex pattern: the agent engages relevant memory before responding, then reflects structured captures (decisions, facts, preferences, skills, reflections) afterward, linked by provenance edges such as DERIVED_FROM and DEPENDS_ON. Wire it up under the [kumiho] config section:

[kumiho]
api_url = "https://api.kumiho.cloud"
auth_token = "..."        # or KUMIHO_AUTH_TOKEN env
space_prefix = "Revka"
mcp_path = "~/.revka/kumiho/run_kumiho_mcp.py"

Learn the pattern in Kumiho graph memory, the Memory overview, and the Graph model reference.

Get started in three steps

1. Install. Use Homebrew, the one-click bootstrap script, a prebuilt binary, or Docker — see Installation.

   brew install revka
   # or
   curl -fsSL https://raw.githubusercontent.com/KumihoIO/Revka/main/install.sh | bash

2. Onboard a provider. revka onboard writes ~/.revka/config.toml with your provider, model, and API key — interactively or non-interactively.

   revka onboard --api-key sk-... --provider openrouter

3. Run and connect. Start the gateway (or full daemon) and open the dashboard or chat with your agent.

   revka gateway

See the Quickstart for the end-to-end walkthrough and the Onboarding wizard for every revka onboard option.

Find your way around

Get started Install, onboard, set up sidecars, and macOS lifecycle.

Concepts The agent loop, autonomy & approvals, sessions, and the security model.

Guides Run the dashboard, chat, connect channels, browser automation, memory.

CLI Every revka command: agent, gateway, cron, channel, models, memory, and more.

Gateway API Pairing & auth, status, sessions, agents, memory, webhooks, realtime.

Dashboard A page-by-page tour of the embedded 18-route web UI.

Channels Connect Telegram, Discord, Slack, Matrix, WhatsApp, email, and more.

Providers Cloud, local, OAuth/subscription, and custom-endpoint model providers.

Tools Filesystem, browser, media, scheduling, delegation, and integration tools.

Memory Kumiho setup, memory tools, the graph model, cache, and isolation.

Workflows & SOP Author YAML workflows and SOPs with steps, triggers, runs, and approvals.

Cron Schedule agent jobs with cron expressions, intervals, and one-shots.

Security Policy & sandboxing, OTP gating, emergency stop, audit log, and IAM.

Deploy Runtime modes, background service, Docker/PaaS, tunnels, and observability.

Hardware Boards, firmware, GPIO, Raspberry Pi, Aardvark, and the Robot Kit.

MCP & extensibility Revka as an MCP server/client, the skills system, and WASM plugins.

Ecosystem Desktop app, Operator MCP, agent orchestration, A2A, and cloud agents.

Reference The full configuration reference, feature flags, and ADRs.