Feature Parity Tracking

IronClaw vs OpenClaw feature implementation status

Overview

IronClaw is a Rust reimplementation inspired by OpenClaw. This document tracks feature parity between the two projects to coordinate development across contributors.

Current Version: IronClaw 0.13.1

Status Legend

• ✅ Implemented: Feature is complete and working
• 🚧 Partial: In progress or incomplete implementation
• ❌ Not Implemented: Feature not yet started
• 🔮 Planned: In scope but not started
• 🚫 Out of Scope: Intentionally skipped
• ➖ N/A: Not applicable to Rust implementation

Key Architectural Differences

IronClaw intentionally differs from OpenClaw in several areas:

1. Rust vs TypeScript

• Native performance: No runtime overhead
• Memory safety: Compile-time guarantees
• Single binary: No dependencies required

2. WASM Sandbox vs Docker

• Lightweight: WASM modules vs full containers
• Faster startup: Milliseconds vs seconds
• Capability-based security: Explicit permission model

3. Database Strategy

• PostgreSQL + libSQL: Dual backend support
• Production-ready: PostgreSQL for production
• Zero-dependency mode: Embedded libSQL for development

4. NEAR AI Focus

• Primary provider: NEAR AI as default LLM backend
• Session-based auth: OAuth flow with refresh tokens

5. No Mobile/Desktop Apps Initially

• Server-first: Focus on core agent functionality
• CLI/TUI: Terminal interface for power users
• Web gateway: Browser-based control UI

6. Novel Features

• WASM channels: Extension mechanism unique to IronClaw
• Tinfoil provider: Private/encrypted inference
• Prompt-based skills: Trust gating and attenuation

Implementation Progress by Category

Core Systems (85% Complete)

Feature	Status	Priority	Notes
Agent loop & message handling	✅	P0	Complete
Session management	✅	P0	Per-sender sessions
Context compaction	✅	P0	Auto summarization
Multi-provider failover	✅	P1	FailoverProvider with retry logic
WASM sandbox	✅	P0	Capability-based permissions
Docker sandbox	✅	P0	Orchestrator/worker pattern
Hybrid search (BM25 + vector)	✅	P0	RRF algorithm
Prompt injection defense	✅	P0	Pattern detection + sanitization
Skills system	✅	P0	Prompt-based with trust gating
Heartbeat system	✅	P0	Periodic execution
Configuration hot-reload	❌	P2	Requires file watching
Global sessions	❌	-	Optional shared context
Multi-agent routing	❌	-	Workspace isolation

Messaging Channels (60% Complete)

Channel	Status	Priority	Notes
CLI/TUI	✅	P0	Ratatui-based
HTTP webhook	✅	P0	Secret validation
Web gateway chat	✅	P0	SSE + WebSocket
Telegram	✅	P1	WASM channel (MTProto)
Slack	✅	P1	WASM tool
Signal	✅	P2	signal-cli integration
WhatsApp	❌	P1	Baileys integration needed
Discord	❌	P2	discord.js equivalent
iMessage	❌	P3	BlueBubbles/Linq
Matrix	❌	P3	E2EE support

Channel Features

Feature	Status	Notes
DM pairing codes	✅	ironclaw pairing list/approve
Allowlist/blocklist	🚧	allow_from + pairing store
Thread isolation	✅	Separate sessions per thread
Typing indicators	🚧	TUI + Telegram basic support
Mention-based activation	✅	bot_username config
Per-group tool policies	❌	Allow/deny specific tools
Channel health monitor	❌	Auto-restart crashed channels

LLM Provider Support (70% Complete)

Provider	Status	Priority	Notes
NEAR AI	✅	P0	Primary provider
Anthropic (Claude)	🚧	P0	Via NEAR AI proxy
OpenAI	🚧	P0	Via NEAR AI proxy
OpenRouter	✅	P1	Via OpenAI-compatible adapter
Ollama (local)	✅	P2	Full support via rig
Tinfoil	✅	-	IronClaw-only private inference
AWS Bedrock	❌	P3
Google Gemini	❌	P3
Perplexity	❌	P3	Web search optimization

Provider Features

Feature	Status	Notes
Auto-discovery	❌	Detect available models
Failover chains	✅	FailoverProvider with fallback
Cooldown management	✅	Lock-free per-provider
Per-session model override	✅	TUI model selector

Security & Safety (75% Complete)

Feature	Status	Notes
Gateway token auth	✅	Bearer token
DM pairing verification	✅	Host-based approval
Exec approvals	✅	TUI overlay
TLS 1.3 minimum	✅	rustls
SSRF protection	✅	WASM allowlist
WASM sandbox	✅	IronClaw innovation
Docker sandbox	✅	Orchestrator/worker
Tool policies	✅	Allow/deny lists
Prompt injection defense	✅	Multi-layer defense
Leak detection	✅	Secret exfiltration prevention
Session file permissions	✅	0o600 mode
Webhook signature verification	✅	HMAC validation
Sandbox env sanitization	🚧	Partial implementation
Tailscale identity	❌	Network identity
Trusted-proxy auth	❌	Reverse proxy headers
Device pairing	❌	Multi-device support
SSRF IPv6 bypass block	❌	Block IPv4-mapped IPv6

Memory & Knowledge (80% Complete)

Feature	Status	Notes
Vector memory	✅	pgvector
Session-based memory	✅	Per-sender context
Hybrid search (BM25 + vector)	✅	RRF algorithm
OpenAI embeddings	✅	Default provider
Atomic reindexing	✅	Safe updates
Embeddings batching	✅	embed_batch trait
Flexible path structure	✅	Filesystem-like API
Identity files	✅	AGENTS.md, etc.
Daily logs	✅	Automatic logging
Heartbeat checklist	✅	HEARTBEAT.md
Memory CLI commands	✅	search/read/write/tree/status
Temporal decay	❌	Time-based scoring
MMR re-ranking	❌	Result diversity
LLM query expansion	❌	Expand search queries
Local embeddings	❌	On-device models
Citation support	❌	Source attribution

CLI Commands (75% Complete)

Command	Status	Priority	Notes
run (agent)	✅	P0	Default command
onboard	✅	P0	Setup wizard
tui	✅	P0	Ratatui interface
config	✅	P0	Read/write settings
status	✅	P0	System status
memory	✅	P0	Memory operations
tool	✅	P0	WASM tool management
skills	✅	P0	Skills management
pairing	✅	P0	DM pairing approval
hooks	✅	P2	Lifecycle hooks
completion	✅	P1	Shell completion
gateway	❌	P2	Gateway control
channels	❌	P2	Channel management
cron	❌	P2	Cron job management
doctor	❌	P2	Diagnostics
logs	❌	P3	Log queries

Automation & Hooks (70% Complete)

Feature	Status	Notes
Cron jobs	✅	Routines with cron trigger
Timezone support	✅	Via cron expressions
One-shot/recurring jobs	✅	Manual + cron triggers
beforeInbound hook	✅	Pre-process messages
beforeOutbound hook	✅	Pre-send messages
beforeToolCall hook	✅	Tool execution guard
onMessage hook	✅	Event trigger routines
onSessionStart hook	✅	Session lifecycle
onSessionEnd hook	✅	Session cleanup
transformResponse hook	✅	Response modification
Bundled hooks	✅	Audit + declarative rules
Plugin hooks	✅	WASM capabilities.json
Workspace hooks	✅	hooks/hooks.json
Outbound webhooks	✅	Fire-and-forget delivery
Heartbeat system	✅	Periodic execution
before_agent_start hook	❌	Model override
before_message_write hook	❌	Pre-write interception
llm_input/llm_output hooks	❌	LLM payload inspection
Cron stagger controls	❌	Job spacing

Web Interface (65% Complete)

Feature	Status	Notes
Control UI Dashboard	✅	Web gateway
WebChat interface	✅	SSE/WebSocket streaming
Debug/logs viewer	✅	Real-time log streaming
Model selection	✅	TUI only
Gateway status widget	🚧	Partial implementation
Channel status view	❌	Full channel overview
Agent management	❌	Multi-agent control
Config editing	❌	Web-based settings
Canvas system (A2UI)	❌	Agent-driven UI
Control UI i18n	❌	Multi-language support

Plugin & Extension System (70% Complete)

Feature	Status	Notes
Dynamic loading	✅	WASM modules
Manifest validation	✅	WASM metadata
Workspace-relative install	✅	~/.ironclaw/tools/
Channel plugins	✅	WASM channels
Tool plugins	✅	WASM tools
Hook plugins	✅	Declarative hooks
Plugin CLI	✅	tool subcommand
HTTP path registration	❌	Plugin routes
Auth plugins	❌	Custom auth
Memory plugins	❌	Custom backends
Provider plugins	❌	Custom LLM providers
ClawHub registry	❌	Discovery service

Media Handling (10% Complete)

Feature	Status	Priority	Notes
Image processing	❌	P2	Resize, format convert
Audio transcription	❌	P2	Speech-to-text
PDF parsing	❌	P2	Text extraction
MIME detection	❌	P2	File type detection
Vision model integration	❌	P2	Image understanding
Video support	❌	P3	Video processing
TTS	❌	P3	Text-to-speech
Media caching	❌	P3	Performance optimization

Mobile & Desktop Apps (Out of Scope)

Feature	Status	Priority	Notes
iOS app	🚫	-	Out of scope initially
Android app	🚫	-	Out of scope initially
macOS app	🚫	-	Out of scope initially
Apple Watch	🚫	-	Out of scope initially
SwiftUI interfaces	🚫	-	Focus on server-side
APNs push notifications	🚫	-	Mobile dependency

Priority Definitions

P0 - Core (Already Done)

Essential features for basic functionality:

• ✅ Agent loop and message handling
• ✅ Session management and context compaction
• ✅ WASM and Docker sandboxes
• ✅ Hybrid search with pgvector
• ✅ Prompt injection defense
• ✅ Skills system with trust gating
• ✅ Core channels (TUI, HTTP, WebChat)
• ✅ Gateway control plane
• ✅ Memory CLI commands

P1 - High Priority

Important features for production use:

• ✅ Multi-provider failover
• ✅ Telegram WASM channel
• ✅ Hooks system (core + bundled/plugin/workspace)
• ❌ WhatsApp channel
• ✅ OpenRouter/OpenAI-compatible provider support

P2 - Medium Priority

Enhanced functionality:

• ❌ Media handling (images, PDFs)
• ✅ Ollama/local model support
• ❌ Configuration hot-reload
• ❌ Channel health monitor
• ❌ Gateway and cron CLI commands

P3 - Lower Priority

Nice-to-have features:

• ❌ Discord, Matrix channels
• ❌ TTS/audio features
• ❌ Video support
• ❌ Streaming (block/tool/Z.AI)
• ❌ Memory advanced features (temporal decay, MMR)
• ❌ Control UI i18n

How to Contribute

1. Claim a Feature

Edit FEATURE_PARITY.md in the source repository and add your name/handle to the “Owner” field for your chosen section.

2. Create Tracking Issue

Open a GitHub issue for the feature area:

Title: Implement [Feature Name]

Description:
- Feature category: [Category]
- Priority: [P0/P1/P2/P3]
- Current status: [❌/🚧]
- Target status: [✅]

Implementation plan:
1. Step one
2. Step two
3. ...

Related files:
- src/...
- tests/...

3. Update Status

As you work:

• Change ❌ to 🚧 when starting
• Update to ✅ when complete
• Add notes for design decisions or deviations

4. Update in PR

Include FEATURE_PARITY.md updates in your pull request:

| Feature | OpenClaw | IronClaw | Notes |
|---------|----------|----------|-------|
- | Hot-reload | ✅ | ❌ | |
+ | Hot-reload | ✅ | ✅ | Uses notify crate for file watching |

Coordination

Section Ownership

• Each major section should have one owner to avoid conflicts
• Owners can delegate sub-features to others
• Update ownership in FEATURE_PARITY.md

Communication

• GitHub Issues: Track feature implementation
• Pull Requests: Include parity updates
• Discussions: Ask questions and propose designs
• Telegram: @ironclawAI for real-time chat

Review Process

1. Reviewers verify parity updates match code changes
2. Status changes must be accurate
3. Notes should explain any deviations from OpenClaw
4. Priorities can be adjusted with justification

Current Status Summary

As of version 0.13.1:

Category	Completion	Notes
Core Systems	85%	Context, sessions, failover complete
Messaging Channels	60%	Core channels done, WhatsApp/Discord pending
LLM Providers	70%	NEAR AI, OpenRouter, Ollama supported
Security & Safety	75%	WASM/Docker sandboxes, prompt defense done
Memory & Knowledge	80%	Hybrid search, embeddings, CLI complete
CLI Commands	75%	Core commands done, management tools pending
Automation & Hooks	70%	Cron, core hooks, webhooks working
Web Interface	65%	Gateway, chat, logs complete
Plugin System	70%	WASM loading, tools, channels working
Media Handling	10%	Major gap - images, audio, PDF needed
Mobile/Desktop	0%	Out of scope initially

Overall Progress: ~65% feature parity

Next Major Milestones

Q2 2026

• Complete WhatsApp channel (P1)
• Implement media handling (P2)
• Add configuration hot-reload (P2)
• Enhance channel health monitoring (P2)

Q3 2026

• Discord channel implementation (P2)
• Advanced memory features (temporal decay, MMR) (P3)
• Streaming support (block/tool-level) (P3)
• Control UI internationalization (P3)

Q4 2026

• Matrix and additional messaging channels (P3)
• TTS/audio features (P3)
• Video processing support (P3)
• Plugin registry/ClawHub (P3)

Resources

• OpenClaw Repository: github.com/openclaw/openclaw
• IronClaw Repository: github.com/nearai/ironclaw
• Full Parity Matrix: See FEATURE_PARITY.md in source repository
• Contributing Guide: /development/contributing
• Building Guide: /development/building
• Testing Guide: /development/testing

Questions?

If you’re unsure whether a feature is in scope or how to implement it:

1. Check the full FEATURE_PARITY.md in the source repository
2. Search existing GitHub issues
3. Open a discussion on GitHub
4. Ask in the Telegram group

We’re here to help you contribute successfully!