Kaze vs OpenFang — Complete Comparison
Part of Project Kaze ArchitectureDate: 2026-02-27
At a Glance
| Dimension | Kaze | OpenFang |
|---|---|---|
| What it is | Agent OS for SME clients (venture studio platform) | Agent OS for autonomous agents (single-binary runtime) |
| Stage | Architecture & design docs complete, entering implementation | Production codebase — 137K LOC Rust, 1,767+ tests |
| Language | TypeScript | Rust |
| Binary | Distributed system (K8s, Postgres, NATS, Vault) | Single ~32MB binary, SQLite embedded |
| Built by | Speedrun Ventures (venture studio) | RightNow AI (Jaber / @Akashi203) |
| License | Private | MIT / Apache 2.0 |
1. Architecture Philosophy
| Aspect | Kaze | OpenFang |
|---|---|---|
| Pattern | Agent-Oriented (Actor + EDA + Cell hybrid) | Kernel-centric monolith in a single binary |
| Layers | 5 explicit layers (Infra → Interaction → Execution → Orchestration → Governance) | Flat crate structure (14 crates, kernel coordinates all) |
| Deployment unit | Cells (isolated per-tenant K8s namespaces) | Single process per node |
| Messaging | Direct calls MVP → NATS Phase 2 | In-process channels + OFP P2P protocol |
| Multi-tenancy | Core design — ABAC, cell isolation, data sovereignty | Not a primary concern — single-user/single-org focus |
| Self-improvement | Layer 3 governance agents (supervisors, quality monitors, improvement agents) | Not present — no self-modification loop |
Key difference: Kaze is designed as a multi-tenant platform for operating agent fleets across many clients. OpenFang is a single-deployment runtime where one operator runs their own agents.
2. Agent Model
| Aspect | Kaze | OpenFang |
|---|---|---|
| Definition | YAML + TypeScript hybrid (skills + agent templates) | TOML config + system prompts per template |
| Pre-built agents | 0 (design phase) | 30 templates + 7 "Hands" (autonomous agents) |
| Composition | Agents = skills + role + context + knowledge deps | Agents = model + system prompt + capabilities + tools |
| Supervision | Per-skill ramp (supervised → sampling → autonomous) | Capability-based RBAC (static, declared at creation) |
| Lifecycle | Actor model: initializing → ready → executing → idle → shutdown | spawn → running → paused → killed |
| Autonomy | Graduated trust per skill | Full autonomy within declared capabilities |
Key difference: Kaze has a supervision ramp — agents earn autonomy over time per skill. OpenFang gives agents full autonomy within their capability set from the start.
3. Knowledge & Memory
| Aspect | Kaze | OpenFang |
|---|---|---|
| Memory types | 4 explicit types: episodic, semantic, procedural, reflective | 4-layer: short-term, long-term, vector, metadata |
| Storage | PostgreSQL + pgvector (shared) + Mem0 (per-agent) | SQLite + embedded vector embeddings |
| Shared knowledge | Core feature — cross-agent knowledge graph with quality gates, provenance, ABAC | Per-agent only — no shared knowledge layer |
| Retrieval | Tri-factor scoring (recency × importance × relevance) + graph traversal | Vector similarity + memory decay |
| Versioning | Git-inspired commits with provenance chain | No versioning — append/overwrite |
| Quality gates | LLM-as-judge + cross-reference + source verification before shared writes | None — direct writes |
| Graph | pgvector Phase 1, Apache AGE Phase 2 | Basic entity/relation storage (knowledge_add_entity) |
Key difference: Kaze's knowledge system is designed for cross-agent, cross-vertical knowledge sharing with heavy governance. OpenFang's memory is per-agent, pragmatic, and lightweight.
4. LLM Integration
| Aspect | Kaze | OpenFang |
|---|---|---|
| Abstraction | LLM Gateway service (centralized) | Per-agent driver (3 native drivers) |
| Providers | Multi-provider via gateway (Anthropic, OpenAI, Google, Ollama) | 27 providers, 51+ models via OpenAI-compatible routing |
| Key management | Dual-key model (Speedrun keys + client BYOK), Vault-managed | Environment variables, per-agent override |
| Budget enforcement | Per-tenant, per-agent token budgets with hard stops | Metering and cost tracking in kernel |
| Model selection | Model hints (fast/balanced/best/embed/judge) → per-tenant mapping | Per-agent model config, manual selection |
| Fallback | Automatic provider fallback chain | Fallback to alternative providers |
Key difference: Kaze centralizes all LLM access through a gateway with budget enforcement and dual-key BYOK. OpenFang gives each agent direct driver access with lighter-weight metering.
5. Tool & Skill System
| Aspect | Kaze | OpenFang |
|---|---|---|
| Built-in tools | 5 MVP integrations (GitHub, Calendar, SEMrush, GSC, Toddle DB) | 53+ built-in tools (file, web, shell, memory, scheduling, messaging) |
| Skills | YAML-defined, composable, vertical-specific | 60 bundled skills (DevOps, cloud, languages, DBs, security, writing) |
| Skill runtimes | TypeScript handlers | Python, WASM, Node.js, prompt-only (Markdown) |
| Auth | Vault-managed credentials, per-tenant scoped | Capability declarations + credential vault |
| MCP | Not present | Full MCP client + server mode |
| Sandbox | Not detailed yet | WASM dual-metered sandbox (fuel + epoch) |
Key difference: OpenFang ships with massive breadth (53 tools, 60 skills, 4 runtimes). Kaze is focused on vertical-specific integrations with deeper auth and tenant isolation.
6. Communication Channels
| Aspect | Kaze | OpenFang |
|---|---|---|
| Channels | CLI/chat MVP, multi-channel Phase 2 (Slack, Email, WhatsApp, Telegram) | 40 adapters (Telegram, Discord, Slack, WhatsApp, Email, Matrix, Signal, IRC, etc.) |
| Conversation layer | OpenClaw (delegated) | Built-in per-channel adapters |
| Cross-channel context | Unified thread model (designed, not built) | Per-channel sessions |
Key difference: OpenFang ships with 40 channel adapters today. Kaze delegates conversation management to OpenClaw and plans multi-channel for Phase 2.
7. Security
| Aspect | Kaze | OpenFang |
|---|---|---|
| Approach | Defense-in-depth per component (11 controls across 6 components) | 16 independent security layers |
| Tenant isolation | Cell-based architecture, ABAC, data sovereignty | Capability-based RBAC per agent |
| Secrets | HashiCorp Vault, automated rotation, anomaly detection | Credential vault, zeroization |
| Audit | Append-only observation logger, secret redaction | Merkle hash-chain audit trail (tamper-proof) |
| Prompt injection | Instruction hierarchy + output validation | Prompt injection scanner |
| Sandbox | Not detailed | WASM dual-metered sandbox, subprocess sandbox |
| Network | Egress whitelist per tenant/vertical | SSRF protection, capability-scoped network access |
| Threat model | Full documented threat model (10 attack surfaces) | SECURITY.md with 16 systems documented |
Key difference: Kaze's security is tenant-oriented (isolating client data across a multi-tenant platform). OpenFang's security is execution-oriented (preventing agents from escaping their sandbox).
8. Deployment & Operations
| Aspect | Kaze | OpenFang |
|---|---|---|
| Deployment | K8s clusters, OpenTofu IaC, Kustomize overlays, ArgoCD/Flux GitOps | Single binary, Docker, Tauri desktop app |
| Dependencies | K8s, Postgres, Vault, NATS, Prometheus, Grafana, Loki | Zero external deps (SQLite embedded) |
| Modes | Agency (multi-tenant SaaS) + Customer VPC (single-tenant) | Local daemon, Docker container, desktop app |
| Cold start | Not measured (distributed system) | <200ms |
| Idle memory | Not measured | 40MB |
| Observability | OTel + Prometheus + Grafana + Loki | tracing + JSON logs |
| Scaling | Horizontal via cells, metric-triggered | Single-node (P2P via OFP for future distribution) |
Key difference: Kaze is a distributed system requiring infrastructure orchestration. OpenFang is a self-contained binary that runs anywhere with zero deps.
9. Business Model & Positioning
| Aspect | Kaze | OpenFang |
|---|---|---|
| Target | Speedrun's SME clients (agency model) | Individual developers, small teams, self-hosters |
| Revenue | BYOK-first + tiered subscription (Starter/Growth/Enterprise) | Open source (MIT/Apache 2.0) |
| Differentiation | Cross-agent knowledge flywheel, vertical depth, supervision ramp | Performance, security layers, zero-dep simplicity, breadth |
| Verticals | SEO, Activity Discovery (Toddle), Internal Ops | General-purpose (30 templates cover many domains) |
| Knowledge moat | Compounding vertical knowledge across clients (with consent) | No cross-agent knowledge sharing |
10. Maturity & Readiness
| Aspect | Kaze | OpenFang |
|---|---|---|
| Code | 0 LOC (design docs only) | 137,728 LOC Rust |
| Tests | None | 1,767+ tests |
| Docs | 8 architecture docs + 6 research docs + 5 project notes | 17 documentation files |
| Pre-built agents | 0 | 30 templates + 7 Hands |
| Tools/Skills | 5 planned | 53 tools + 60 skills |
| Channels | 0 (OpenClaw planned) | 40 adapters |
Where Kaze Has an Edge (by design)
- Multi-tenant isolation — Cell architecture, ABAC, data sovereignty per client
- Shared knowledge with governance — Quality-gated, versioned, provenance-tracked cross-agent knowledge
- Supervision ramp — Graduated trust model (supervised → sampling → autonomous) per skill
- Vertical depth — Domain-specific knowledge compounding across clients
- Client BYOK + budget enforcement — Enterprise-grade LLM cost management
- Self-improvement loop — Layer 3 governance agents (supervisor, quality monitor, improvement)
Where OpenFang Has an Edge (shipped today)
- Exists as working software — 137K LOC, 1,767 tests, production-ready
- Zero dependencies — Single binary, SQLite, runs anywhere in <200ms
- Breadth — 53 tools, 60 skills, 40 channels, 27 providers, 30 agent templates, 7 autonomous Hands
- Performance — Rust, 40MB idle, <200ms cold start
- Security depth — 16 independent security layers including WASM sandbox, Merkle audit, taint tracking
- Desktop app — Tauri native app for Windows/macOS/Linux
Strategic Assessment
Kaze and OpenFang solve different problems:
- OpenFang = "Run powerful autonomous agents locally with zero setup." Individual/small-team tool.
- Kaze = "Operate fleets of AI agents across many clients with shared knowledge and governance." Platform/agency infrastructure.
They could be complementary rather than competitive — OpenFang as a lightweight agent runtime, Kaze as the multi-tenant orchestration and knowledge layer on top. The key question is whether Kaze should build its own runtime from scratch or consider adopting/adapting something like OpenFang's runtime as a foundation.
Potential Synergies
| Scenario | What it looks like |
|---|---|
| OpenFang as Kaze's agent runtime | Kaze wraps OpenFang binary per cell, adds multi-tenancy, knowledge graph, and supervision ramp on top |
| Kaze as OpenFang's enterprise layer | OpenFang handles execution, Kaze provides the SaaS/VPC multi-tenant wrapper with billing, BYOK, and knowledge sharing |
| Independent with shared tools | Both projects contribute to a shared MCP tool ecosystem, remain architecturally separate |
| Competitive | Build Kaze's runtime from scratch in TypeScript, compete on vertical depth and knowledge moat |