CLI-native agent execution
Spawn Claude Code, Codex, Antigravity CLI (`agy`), Cursor CLI (`agent`), and OpenCode as governed workflow agents with inherited MCP servers.
Enterprise Agent Workflow Platform
Enterprise-grade agent workflows, simple enough to start alone.
Revka is an agent workflow platform built on Kumiho graph memory. Start with one operator and a local workflow; keep the same run history, approvals, and tamper-evident audit trail when that work reaches production and security review.
- Verified
- audit chain status
- 5 CLIs
- agent runtimes
- Merkle
- tamper-evident audit log
Easy to start, serious when needed
Run locally, work as a solo builder or small team, and keep a clean path to managed graph memory, service controls, diagnostics, and Enterprise self-hosting.
Audit-first operations
Merkle hash-chain audit, `/api/audit/verify`, approval records, RunLog JSONL, and visible risk rails are product surfaces, not afterthoughts.
Small enough for one operator. Structured enough for a security review.
Revka is useful before a procurement process exists: local-first workflows, CLI-backed agents, and graph memory make it practical for personal automation and small teams. When the same work becomes critical, Revka already has the records an organization expects: who initiated it, which agent ran it, what tools were called, what approvals were required, what artifacts changed, and what revision should be used next.
- Use local runtime control for personal projects, small internal tools, demos, and repeated agent workflows.
- Add human approval and human input steps directly in the DSL when work needs supervision.
- Keep the same trust scores, provenance edges, checkpoints, revisions, and risk rail as workflows move toward enterprise operation.
Bring the coding agents your company already uses into one governed run.
Revka Operator spawns real coding CLI subprocesses inside declarative workflows. Each agent can carry a persona, role, tool allowlist, timeout, and model override, while Revka injects the MCP servers and records the operational trail.
Claude Code
Use Claude Code sessions for high-context implementation, review, and operator-supervised coding tasks.
Codex
Route codebase work through Codex agents with scoped tools, model choices, and workflow-level evidence capture.
Antigravity CLI
Delegate specialized implementation or exploration steps to Antigravity CLI through the `agy` agent type.
Cursor CLI
Run Cursor CLI as the `agent` runtime when teams want Cursor-native execution under Revka governance.
OpenCode
Use OpenCode CLI for coding work that benefits from its own agent loop, while Revka owns orchestration and audit.
A governed operating layer for agent teams.
Revka combines orchestration, observability, policy, and memory in one runtime surface. Operators can author YAML workflows, execute them, inspect live events, drill into RunLogs, retry or approve work, and preserve the exact context for the next run.
Workflow governance
Declare steps for agent runs, shell and Python execution, human approval and input, parallel and map-reduce fan-out, supervisor and group-chat coordination, handoffs, and structured output.
Operational visibility
Watch WebSocket events, run state, selected step output, tool calls, agent activity, command band status, recent runs, spend, and component health.
Versioned knowledge
Store workflows, outputs, artifacts, sessions, goals, teams, skills, trust records, and provenance in graph memory with revision-level continuity.
Policy and recovery
Use approvals, checkpoints, retries, diagnostics, service controls, E-Stop, workspace boundaries, prompt guard, and secret scanning around real agent work.
Audit is the foreground, not a compliance appendix.
Enterprise agent systems need evidence, not screenshots of a final answer. Revka records runtime events and exposes verification surfaces so teams can prove what happened, inspect why it happened, and continue from the correct state.
Tamper-evident runtime log
#1024
9f2c…41aa #1025c7d1…08be #10265e93…b6f0 Chain verified /api/audit/verify Every runtime event is appended to a Merkle hash chain; the chain can be re-verified at any time.
Per-agent RunLog
{"ts":"04:18:02Z","event":"message","agent":"claude","step":"plan"}
{"ts":"04:18:09Z","event":"tool_call","tool":"shell.run","exit":0}
{"ts":"04:18:31Z","event":"approval","actor":"operator","decision":"approved"}
{"ts":"04:18:32Z","event":"result","status":"ok","hash":"sha256:9f2c…41aa"}Messages, tool calls, approvals, and results land in queryable JSONL — one trail per agent run.
Approval as a workflow primitive
Human approval and human input steps are typed workflow steps, with approval decisions recorded instead of disappearing into chat history.
Trust and provenance
Agent trust scores, revision tags, Kumiho provenance edges, and artifact history keep every output connected to its operational lineage.
Enterprise operators see the system state first.
Unified Command Dashboard
The central operational hub of your agent ecosystem. Track active run sessions, real-time agent memory, API token spend, cluster resource health, and system-wide security posture at a glance.
Visual Workflow Editor
Design robust multi-agent flows with a drag-and-drop workspace or side-by-side YAML authoring. Configure step-level inputs, secret injection, allowed tools, and human-in-the-loop checkpoints.
Real-Time Execution DAG
Monitor tasks as they compile and run. Drill into step outputs, view stdout streams, approve model-recommended actions, and watch parallel reviewer agents collaborate in real-time.
Kumiho Graph Memory Explorer
Navigate connected facts, user sessions, instructions, code revisions, and agent trust signals. Understand semantic provenance tracking to see exactly how and why a memory was generated.
Asset & Artifact Browser
Inspect, manage, and download all generated files, code diffs, structured JSON outputs, and runtime bundles. Each asset is cryptographically hashed for tamper-evident verification.
Tamper-Evident Audit Trails
Query cryptographically chained logs built for non-repudiation. Every message, tool call, shell command, and manual approval is hashed and verifiable under security review.
Three layers, one verifiable operating record.
Revka is the enterprise agent runtime surface. Operator executes declarative workflows. Kumiho provides the versioned graph memory backend that keeps runs, revisions, trust, and provenance traceable across sessions.
Revka runtime
Rust-native gateway, daemon, CLI, channels, tools, dashboard, local service control, diagnostics, metrics, and audit surfaces.
Operator MCP
Python orchestration server for workflow validation, lifecycle management, execution, events, RunLogs, approvals, and agent process control.
Kumiho graph
Version-controlled, schemaless, typed-edge graph memory for artifacts, workflow runs, sessions, provenance, revisions, and agent trust.
How Revka governs Google ADK, A2A, and Cloud Run agent packaging.
The deployment path keeps Revka responsible for workflow state, approvals, logs, artifacts, rollback evidence, and governance while Google Agents CLI handles ADK lifecycle work and A2A makes the deployed agent discoverable across enterprise ecosystems.
Google ADK, governed by Revka
Google Agent Development Kit (ADK) is a production-grade framework for building, evaluating, and deploying agents. Revka wraps ADK execution and evaluation with Merkle hash-chain logging and Kumiho's versioned memory graph, so ADK workloads arrive at security review with their evidence already in order.
- Expose ADK lifecycle commands — compile, test, deploy, evaluate — through the native `[google_agents_cli]` engine.
- Run each ADK agent in a sandboxed workspace step with granular `agent.tools: google_agentops` permissions.
- Isolate and inject GCP credentials — `GOOGLE_APPLICATION_CREDENTIALS`, Vertex AI endpoints, API keys — as managed secrets.
- Convert ADK evaluation and benchmark results into queryable RunLog evidence.
- Coordinate ADK nodes with Claude Code and Codex in one workflow DAG over A2A JSON-RPC 2.0.
Google ADK & Revka Cloud Run Integration Architecture
For solo builders, small teams, and organizations that cannot lose the record of what agents did.
Personal power users and builders who want local-first agent workflows without giving up history, memory, and repeatability.
Small teams turning useful automations into shared workflows with approvals, cost posture, and operational ownership.
Platform teams supervising Claude Code, Codex, Antigravity CLI, Cursor CLI, OpenCode, Google ADK tooling, and A2A agents through repeatable runs.
Enterprise operators who need provenance, security review evidence, deployment choices, and memory continuity.
Start simple. Keep the evidence when it matters.
Revka turns agent orchestration into a verifiable operational system without making the first workflow feel heavy: governed execution, audit-first visibility, and graph memory that remembers the actual work.
git clone https://github.com/KumihoIO/Revka.git