Agent Gateway Comparison

kanipi vs openclaw, nanoclaw, brainpro, muaddib

TL;DR

Five frameworks. Different philosophies. Kanipi is the evolution of NanoClaw with multi-tenancy, 4-tier permissions, and product-as-configuration. It has the highest test coverage (1.04:1) but not the most features. OpenClaw is comprehensive. NanoClaw is minimal. Brainpro is multi-model. Muaddib is multi-tenant hostile-environment. What does Kanipi offer that OpenClaw doesn't? Not much technically—but different design priorities: testability, multi-tenancy, products as configs.

Executive Summary

Framework	LOC (Source)	Files	Language	Architecture	Type	Maturity
OpenClaw	62,955	3,942	TypeScript	Monolithic gateway	Personal assistant	Production (v2026.2.27)
NanoClaw	7,588	26	TypeScript	Single process, containers	Personal assistant	Production (v1.1.3)
Brainpro	26,735	85	Rust	Dual-mode (CLI + daemon)	Coding assistant	Development (v0.1.0)
Muaddib	13,080	59	TypeScript	Multi-tenant, pi SDK	Public team chat	Production (v2.2.0)
Kanipi	10,780	45	TypeScript	Multi-tenant gateway	Multi-channel product	Production (v1.0.8)

What Does Kanipi Actually Offer?

The Honest Critique

Kanipi doesn't provide anything fundamentally new that OpenClaw couldn't do.

Multi-channel support? OpenClaw has 10+ channels vs Kanipi's 5.
Agent orchestration? OpenClaw has multi-agent routing and RPC mode.
Platform apps? OpenClaw has native macOS/iOS/Android apps. Kanipi has none.
Voice capabilities? OpenClaw has Wake Mode, Talk Mode, PTT. Kanipi has basic whisper.
Canvas/A2UI? OpenClaw has live visual workspace. Kanipi has plain text.
Memory layers? Both have similar tiered memory (messages, sessions, diary, facts).

If you want comprehensive platform coverage, OpenClaw is objectively better.

What Kanipi Actually Prioritizes

Design philosophy differences, not feature superiority:

Multi-tenancy by design: 4-tier permission model (root/world/agent/worker) with folder-depth-derived isolation. OpenClaw is single-user.
Products as configurations: Atlas (code support), Yonder (research), Evangelist (planned). Same gateway, different CLAUDE.md + SOUL.md + skills.
Test coverage obsession: 1.04:1 test:code ratio (11,196 LOC tests vs 10,780 LOC source). 521 tests, 81 specs. OpenClaw has tests but different focus.
NanoClaw evolution, not OpenClaw fork: Inherits 7.6K LOC minimalism + container isolation, adds multi-channel + multi-tenant.
Hierarchical delegation: 5 rule types (regex, keyword, command, sender, default) with max depth 3. Parent→child agent routing.
Hot-patching: agent-runner TS source mounted, compiled at runtime. No container rebuild for code changes.

If you want multi-tenant products with test coverage and container isolation, Kanipi fits.

Missing from Kanipi (vs OpenClaw)

No Signal, iMessage, Matrix, Zalo, Google Chat, Teams support
No native platform apps (macOS menu bar, iOS/Android nodes)
No voice-first capabilities (Wake Mode, Talk Mode)
No Canvas/A2UI visual workspace
No device pairing/binding for secure single-user mode
No Clawnet protocol (legacy bridging from clawdbot)

Potential Improvements for Kanipi

Adopt OpenClaw's channel breadth: Add Signal, iMessage, Matrix for comprehensive coverage
Implement facts/episodes memory: Currently planned (v1m1), not yet shipped
Agent teams: Planned (v2m1), but Muaddib already has per-arc isolation patterns to learn from
Go gateway rewrite: Planned (v2m2). Rust (like Brainpro) might be better for resilience patterns
Circuit breaker pattern: Brainpro has proven circuit breaker (Closed→Open→HalfOpen). Kanipi has none
Multi-model routing: Brainpro supports ANY OpenAI-compatible backend. Kanipi is Claude-only
Cost tracking: Brainpro has Prometheus metrics + JSON export. Kanipi has no cost visibility

1. OpenClaw - The Comprehensive Platform

Philosophy: "Everything but the kitchen sink" personal AI assistant

Core Stats

LOC: 62,955 source (500K+ total with extensions/skills)
Files: 3,942 (23 source directories)
Language: TypeScript (Node.js 22+, pnpm monorepo)
Channels: 10+ (WhatsApp/Baileys, Telegram/grammY, Slack/Bolt, Discord, Signal, iMessage, Teams, Matrix, Zalo, Google Chat)
Testing: 1,735 test files; vitest with V8 coverage (70% thresholds)
Dependencies: 70+ (Baileys, grammY, Bolt, discord.js, signal-cli, better-sqlite3)

Unique Differentiators

Largest scope: Every messaging platform covered
Native platform apps: macOS menu bar, iOS/Android nodes
Voice-first: Wake Mode, Talk Mode, PTT (push-to-talk)
Canvas visual workspace: Real-time A2UI for collaboration
Device binding: Tight single-user security with pairing
Legacy bridging: Clawnet protocol migration from clawdbot

Architecture

Gateway (monolithic TypeScript)
  ├── Channels (10+ adapters in-process)
  ├── Multi-agent routing (RPC with workspace isolation)
  ├── Memory (session + persistent files + SQLite)
  ├── Tools (7+ core + Canvas + Browser + Cron/webhooks)
  └── Skills platform (extensible per-workspace)

Trade-offs

Complexity: 500K LOC total. Limited auditability.
Single-user only: No multi-tenancy, no world-scoped permissions.
Feature creep risk: Extensions via PR, not configuration.

2. NanoClaw - The Minimal Masterpiece

Philosophy: "Small enough to understand" (code you can actually audit)

Core Stats

LOC: 7,588 source (smallest by design)
Files: 26 (24 TypeScript, mostly single responsibilities)
Language: TypeScript (Node.js 20+, no monorepo)
Channels: 3 core (WhatsApp/Baileys, Telegram/grammy, Discord) + extensible via skills
Testing: 48 test files (~3.5K LOC, ~0.46:1 ratio)
Dependencies: Minimal (Baileys, grammy, discord.js, better-sqlite3, Zod)

Unique Differentiators

SMALLEST codebase: 7.6K LOC source vs 60K+ for OpenClaw
True OS-level isolation: Docker containers, not application-level allowlists
Designed for auditing: "You should understand this fully"
Skills-first: Extensions via /skill, no monolithic PR merges
Direct Claude Code SDK: Not a wrapper, pure SDK access
Agent swarms: First personal assistant with teams support

Architecture

Gateway (single Node.js process)
  ├── Channels (3 adapters, minimal)
  ├── Container spawn per message (Docker isolation)
  ├── Per-group FIFO queue (SQLite-backed)
  ├── Memory (CLAUDE.md per group + SQLite history)
  └── IPC (filesystem watchers + polling)

Why Choose NanoClaw

If you need to understand and audit every line of code, NanoClaw is unmatched. Single-user, intentionally sparse, designed for customization via user forks.

3. Brainpro - The Rust Powerhouse

Philosophy: "Vendor-neutral multi-model routing with resilience"

Core Stats

LOC: 26,735 source
Files: 85 (organized by domain: agent_impl.rs, policy.rs, backends.rs, tools/)
Language: Rust (2021 edition, tokio async)
Channels: None built-in (library, not service)
Testing: 28 test files; vitest + validation suite with real APIs (~$1.25 cost)
Dependencies: Lean (tokio, reqwest, clap, prometheus, MCP client)

Unique Differentiators

Vendor-neutral: Supports ANY OpenAI-compatible backend (Claude, OpenAI, Ollama, Venice, DeepSeek)
Circuit breaker resilience: Closed→Open→HalfOpen with provider health tracking, jittered backoff
Zero-data-retention policy: Enforcement for ZDR-only providers on sensitive prompts
Plan mode: Strategic reasoning before execution
Subagents with tool restrictions: Delegation with scoped permissions
Cost tracking: Prometheus metrics + JSON export

Architecture

Two execution paths:
  1. CLI binary (yo) - MrCode persona, 7 tools, REPL
  2. Daemon (brainpro-gateway + brainpro-agent)
     - MrBot persona, 13 tools
     - WebSocket (client↔gateway) + Unix socket (gateway↔agent)
     - Turn-based loop (max 12 iterations)
     - Multi-model routing by task type

Why Choose Brainpro

If you need multi-model flexibility, resilience patterns, and cost tracking, Brainpro is the best choice. Rust clarity, policy engine, vendor independence.

4. Muaddib - The Multi-Tenant Specialist

Philosophy: "Public team environments" (not private assistants)

Core Stats

LOC: 13,080 source
Files: 59 (organized: agent/, rooms/{irc,discord,slack}/, tools/, chronicle/)
Language: TypeScript (Node.js 20+, ESM)
Channels: 4 core (IRC/irssi-varlink, Discord, Slack with threading, OpenRouter)
Testing: 33 test files (~5K LOC, ~0.38:1 ratio); vitest with pre-commit hooks
Dependencies: pi-agent-core/ai/coding-agent, gondolin, discord.js, @slack/bolt, croner

Unique Differentiators

Multi-tenant by design: Isolated arcs per channel with no context bleed
QEMU micro-VM isolation: Not containers, not host execution—full Gondolin VMs
Token optimization: Context engineering for cost efficiency
Battle-tested in hostile IRC: Handles libera.chat, rate limiting, lurk mode
Artifact generation: Publish results to web
Command modes: Multiple prefixed modes (!h help, !d draft, !a analyze)

Architecture

Gateway (TypeScript, pi SDK override)
  ├── Channels (IRC, Discord, Slack, OpenRouter)
  ├── Per-arc Gondolin micro-VMs (QEMU)
  ├── 4-layer memory:
  │   ├── Short-term: smart context engineering
  │   ├── Mid-term: scratchpad (working memory)
  │   ├── Long-term episodic: chronicle (continuous events)
  │   └── Long-term procedural: auto-maintained skills
  └── Lurk-by-default with opt-in proactive interjecting

Why Choose Muaddib

If you need multi-tenant isolation in hostile public environments, Muaddib is proven. QEMU VMs, cost-optimized, IRC battle-tested.

5. Kanipi - The Modern Product Gateway

Philosophy: "Multi-tenant, multi-channel products as configurations"

Core Stats

LOC: 10,780 source, 11,196 test (1.04:1 ratio)
Files: 45 source, 39 test files
Language: TypeScript (Node.js 20+, ESM, NodeNext)
Channels: 5 adapters (Telegram/grammy, Discord, WhatsApp/Baileys, Email/imapflow+nodemailer, Web/Slink HMAC JWT + SSE)
Testing: 521 tests, 81 specs
Dependencies: Claude Code SDK, grammy, discord.js, Baileys, imapflow, nodemailer, better-sqlite3, Zod

What Makes Kanipi Different

NanoClaw evolution: Fork with multi-tenancy + multi-channel + product-as-config
4-tier permission model: root/world/agent/worker (folder-depth-derived with mount isolation)
Hierarchical delegation: 5 rule types (regex, keyword, command, sender, default), max depth 3
Products as configs: Atlas (code support), Yonder (research), Evangelist (planned). Same gateway, different CLAUDE.md + SOUL.md + skills.
Hot-patching: agent-runner TS source mounted, compiled at runtime (no container rebuild)
6-layer memory: Messages (SQLite, stdin XML) → Session (SDK JSONL, --resume) → Managed (CLAUDE.md + MEMORY.md) → Diary (markdown, YAML frontmatter) → Facts (planned) → Episodes (planned)
Voice transcription: Whisper sidecar with per-group language hints
Modern web stack: Vite dev server, Slink (HTTP POST) with HMAC JWT + SSE streaming, sloth.js widget

Architecture

Gateway (TypeScript ESM)
  ├── Channels (5 adapters: tg, discord, wa, email, web)
  ├── SQLite DB (message store + attachments)
  ├── GroupQueue (per-group FIFO, one agent at a time)
  ├── Router (JID → group lookup, prompt assembly, diary injection)
  ├── Container (docker run, stdin pipe, mount /workspace/{group,share,web,ipc})
  ├── Claude Code SDK (tools, subagents, skills, MCP)
  ├── IPC (SIGUSR1 + 500ms fallback poll, file-based request/response)
  └── Action Registry (Zod-validated, tier-authorized)

When to Choose Kanipi

If you need multi-tenant products with test coverage and container isolation, Kanipi fits. Not as comprehensive as OpenClaw, not as minimal as NanoClaw, but optimized for product-as-configuration with 4-tier permissions.

Roadmap

v1m1: Facts injection, SSE per-sender
v1m2: Message MCP tools, agent messaging
v2m1: Episodic memory, agent teams, feed adapters
v2m2: Go gateway rewrite (single binary)

Comparative Analysis: Design Decisions

Security Model

Framework	Isolation	Policy	Threat Model
OpenClaw	Application-level (allowlists, pairing)	Config-based	Single-user trust boundary
NanoClaw	OS-level (Docker containers)	Filesystem mounts	True isolation, code auditable
Brainpro	N/A (library)	Policy engine (allow/ask/deny)	Per-tool permission checking
Muaddib	QEMU micro-VMs	Per-arc isolation	Public hostile environment
Kanipi	OS-level (Docker) + tier-based	4-tier folder-depth permission	Multi-tenant, world-scoped

Multi-Channel Support

Framework	Channels	Approach
OpenClaw	10+ (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, Matrix, Zalo, Google Chat)	Monolithic (every channel in one place)
NanoClaw	3 core + extensible	Skills-first (users add channels)
Brainpro	0 (library)	Integrations external
Muaddib	4 (IRC, Discord, Slack, OpenRouter)	Native adapters per platform
Kanipi	5 (Telegram, Discord, WhatsApp, Email, Web)	Adapter pattern (Channel interface)

Testing Coverage

Framework	Test Files	LOC (Test)	Ratio	Type
OpenClaw	1,735	Not isolated	High	Unit + integration + live
NanoClaw	48	~3.5K	~0.46:1	Unit + container isolation
Brainpro	28	Embedded	Low	Unit + integration with real APIs
Muaddib	33	~5K	~0.38:1	Unit + e2e + vitest
Kanipi	39	11,196	1.04:1	Unit + integration + 521 tests

Key Architectural Patterns & Convergence

Pattern 1: Container Isolation (NanoClaw, Kanipi)

Lesson: Real security requires OS-level isolation

Trade-off: More overhead than shared memory, but auditable

Adoption: Kanipi extends NanoClaw's model with multi-tenancy

Pattern 2: SQLite for Message Store (OpenClaw, NanoClaw, Kanipi)

Lesson: better-sqlite3 provides ACID guarantees without network complexity

Trade-off: Not distributed, but sufficient for single-host gateways

Pattern 3: Per-Group Isolation (NanoClaw, Muaddib, Kanipi)

Lesson: Multi-tenant systems need isolated state trees

Trade-off: Complexity increases with tier-based permissions

Pattern 4: Filesystem IPC (NanoClaw, Kanipi)

Lesson: Signal + file watching beats socket complexity for local systems

Trade-off: 500ms fallback latency is acceptable for agent use

Pattern 5: Skill/Extension Model (NanoClaw, Brainpro, Muaddib, Kanipi)

Lesson: Features should be added via configuration, not PR merges

Convergence: All new frameworks reject monolithic expansion

Pattern 6: Memory Layering (Brainpro, Muaddib, Kanipi)

Lesson: Multiple persistence scopes (session, daily, facts, episodes) needed

Convergence: All support some form of tiered memory injection

What You Should Choose

Goal	Best Fit	Why
Comprehensive personal assistant	OpenClaw	Every platform, native apps, platform polish
Code you can audit completely	NanoClaw	7.6K LOC, single-user focus
Multi-model vendor flexibility	Brainpro	Circuit breaker, provider health, ZDR policy
Public/hostile multi-user environment	Muaddib	QEMU isolation, lurk mode, cost-optimized
Enterprise multi-tenant products	Kanipi	4-tier perms, products-as-config, test coverage
Learning how agents work	Brainpro	Rust clarity, policy engine, minimal dependencies

Final Verdict: What Makes Kanipi Special?

Honest answer: Not much that OpenClaw couldn't technically do.

Kanipi is not a technical breakthrough. It's a design priorities shift:

Multi-tenancy over single-user: 4-tier permissions, world-scoped authorization
Products-as-config over feature PRs: Atlas, Yonder, Evangelist = same gateway, different configs
Test coverage over feature breadth: 1.04:1 test:code ratio, 521 tests, 81 specs
Container isolation over app-level allowlists: Inherits NanoClaw's auditable security
Minimalism over comprehensiveness: 10.8K LOC vs OpenClaw's 500K+

If You Want Comprehensive Coverage: Use OpenClaw

OpenClaw has more channels, native apps, voice-first, Canvas, device pairing. It's objectively more feature-complete.

If You Want Multi-Tenant Products with Test Coverage: Use Kanipi

Kanipi prioritizes multi-tenancy, products-as-config, and test coverage. It's the NanoClaw evolution for enterprise use cases.

Clear convergence toward container isolation, tiered memory, and configuration-based products, with Kanipi representing the most pragmatic balance of production-readiness, test coverage, and multi-tenant extensibility.