CLI-native agent execution
Spawn Claude Code, Codex, Antigravity CLI (`agy`), Cursor CLI (`agent`), and OpenCode as governed workflow agents with inherited MCP servers.
REVKA · Enterprise-Ready Agent Workflow Platform built on Kumiho
Enterprise-grade agent workflows, simple enough to start alone.
Revka is an enterprise-ready agent workflow platform built on https://kumiho.io. Start with one operator, a local workflow, or a small agent team. Revka keeps the same run history, DAGs, tool calls, approvals, RunLogs, revisions, trust signals, and tamper-evident audit checks when that work grows into production and security review.
- Verified
- audit chain status
- 5 CLIs
- agent runtimes
- Persona
- tool and model scoped
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.
From personal to enterprise
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.
CLI-native agent teams
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.
Runtime control
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 agent, shell, Python, compute, email, image, approval, parallel, map-reduce, supervisor, group chat, handoff, resolve, tag, deprecate, and structured output steps.
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 by design
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
Runtime audit uses Merkle hash-chain logging with cryptographic verification and an `/api/audit/verify` surface for chain checks.
Per-agent RunLog
Each agent run can leave JSONL activity trails for messages, tool calls, results, errors, and final output, queryable from the dashboard.
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.
Product proof
Enterprise operators see the system state first.
01
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.
02
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.
03
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.
04
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.
05
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.
06
Tamper-Evident Audit Trails
Query cryptographically chained logs that guarantee complete non-repudiation. Every message, tool call, shell command, and manual approval is hashed and verifiable under security reviews.
Architecture
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.
Reference architecture
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 and open agent ecosystem
Uncompromising reliability: Why Google ADK powers Revka for Enterprise
Google Agent Development Kit (ADK) positions itself as the industry-standard, production-grade framework for building, evaluating, and deploying highly reliable agents. Revka elevates Google ADK to an enterprise-compliant powerhouse by wrapping its robust agent execution, safety-checking, and evaluation capabilities with Revka's tamper-evident Merkle hash-chain logging and Kumiho's versioned memory graph. Together, they form an elite, compliant runtime that satisfies rigorous corporate security reviews.
- Enable native `[google_agents_cli]` to expose ADK / Agent Platform lifecycle commands (compile, test, deploy, evaluate) directly through the Revka runtime.
- Govern ADK workflows with strict security boundaries; each ADK agent runs inside a sandboxed CLI-backed workspace step with granular `agent.tools: google_agentops` permissions.
- Maintain absolute credential hygiene by safely isolating and injecting GCP environment variables including `GOOGLE_APPLICATION_CREDENTIALS`, Vertex AI endpoints, and secure API keys.
- Leverage Google ADK's native agent evaluation and dataset validation features, automatically converting benchmark results into queryable, unalterable RunLog compliance proofs.
- Facilitate secure machine-to-machine collaboration via robust A2A JSON-RPC 2.0 interoperability, allowing ADK-managed nodes to coordinate with Claude Code and Codex in a unified workflow DAG.
Google ADK & Revka Cloud Run Integration Architecture
Who it is for
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.