PT·EN·ES← INTELECTO v2 · guideGrocery store: choose the ingredients, download your meu-assistente.md, and give it to Claude Code or Codex inside the intelecto-v2 folder.INEMA.CLUB

AI Agent Framework Grocery Store

12 frameworks analyzed. Hundreds of features extracted. Choose the ingredients that matter to YOUR business.

12
Frameworks
7
Languages
144
Available Features
40+
Supported AI Models

How to use the grocery store

The grocery store doesn’t install anything: it creates a shopping list in Markdown (meu-assistente.md) for a coding agent to read and build your assistant on top of INTELECTO v2, which is already running.

1Choose ingredients from the aisles below, or load one of the 5 ready-made examples.
2Open the cart and click Export: this downloads meu-assistente.md. Each item says whether it already exists in v2, is partial, or which piece to add it to.
3Copy the file into the intelecto-v2 folder, open Claude Code or Codex there, and paste the request below.
cd ~/intelecto-v2 && cp ~/Downloads/meu-assistente.md .
# in Claude Code or Codex, open in this folder, paste:
Read meu-assistente.md and implement the ingredients marked as "to add" and "partial",
one at a time, following the "Rules for the agent" at the end of the file.
Run python3 -m pytest -q after each one and show me the output.

Safer: run the agent inside caixa-do-agente and apply only the patch you reviewed (patch -p1).

5 ready-made examples

Click the diagram to enlarge it. "Load into cart" marks the ingredients in the aisles (you can remove or add more); "Download the .md" gives you the file.

Diagram of the personal Jarvis on Telegram example

1. Personal Jarvis on Telegram

For anyone who wants an assistant on their phone that remembers things, gives timely reminders, and takes care of email and their calendar.

12 ingredients
Diagram of the small business attendant example

2. Small Business Assistant

For a shop or clinic that gets questions on WhatsApp and wants to answer based on its own documents, without falling for malicious messages.

12 ingredients
Diagram of the secure programmer example

3. Secure Programmer

For anyone who lets an agent work on code: it works in a sandbox, asks for approval before risky actions, and only says it’s done when the tests pass.

12 ingredients
Diagram of the 100% local and private example

4. 100% Local and Private

For anyone who doesn’t want anything leaving their computer: local AI, local voice, private search, and your notes.

10 ingredients
Diagram of the voice-controlled smart home example

5. Voice-Controlled Smart Home

For anyone who wants to talk to their home: wake word, lights, sound, cameras, and routines, with approval required before any sensitive action.

12 ingredients

The 12 Frameworks at a Glance

Each card captures the essence of a framework. Think of them as the "brands" in your grocery store.

OC

OpenClaw

The Original Platform
TypeScript

The complete "operating system" for personal AI. Think of it as the iPhone of AI assistants: polished, integrated, everything works together. The Gateway architecture routes all your messages, voice, and visual canvas through a single control center.

Gateway Hub Voice Wake Canvas UI Plugin SDK Multi-Agent macOS/iOS Apps
10+
Channels
6+
AI Providers
195K
GitHub Stars
ZC

ZeroClaw

The Efficiency Engine
Rust

OpenClaw reimagined in Rust for extreme efficiency. Runs on a $10 board with less than 5MB of RAM. Starts up in 10ms. Every component is an interchangeable "trait" (contract)—swap your AI model, messaging app, or storage without touching the agent’s code.

Trait Architecture AIEOS Identity Hybrid Search Encrypted Secrets
<5MB
RAM Usage
22+
AI Providers
10ms
Boot Time
NC

NanoClaw

The WhatsApp Assistant
TypeScript

A masterpiece of simplicity with 5,200 lines. Your AI lives in WhatsApp. Each conversation group has its own brain, isolated in a secure container. Small enough to read all at once, powerful enough for everyday business use. A "no setup complexity" philosophy.

Container Isolation 5,200 Lines Total Group Memory Skills System
5.2K
Lines of Code
1
Main Channel
VM
Isolation Level
NB

NanoBot

The Python Polyglot
Python

Ultra-lightweight Python framework with 4,000 core lines that supports 9+ chat platforms and 13+ AI providers. Uses a message bus architecture to keep channels, agents, and memory clearly separate. Ready for research and easy to extend.

Message Bus Soul.md 13+ Providers MCP Support
4K
Core Lines
9+
Channels
13+
AI Providers
PC

PicoClaw

The Edge Executor
Go

Runs your AI assistant on a $10 circuit board. Written in Go for extreme portability. Single 10MB binary, no dependencies. It can even control hardware pins for IoT devices. Perfect for always-on AI, deployed anywhere, with almost no operating cost.

$10 Hardware GPIO/I2C/SPI Single Binary RISC-V Support
<10MB
RAM Usage
8+
Channels
400x
Faster Startup
IC

IronClaw

The Security Fortress
Rust

The "Fort Knox" of AI assistants. Tools run in WASM sandboxes that can’t leak your secrets. Built-in defense against prompt injection. Supports two databases (PostgreSQL + SQLite). If you handle sensitive data, IronClaw’s zero-trust architecture is the gold standard.

WASM Sandbox Leak Detection Prompt Injection Defense Dual Database
WASM
Sandbox Type
5+
Parallel Jobs
40+
Web API Routes
TC

TinyClaw

The AI Team Builder
TypeScript/Bash

Build teams of AI agents that collaborate autonomously. @coder fixes bugs, hands off to @reviewer, who hands off to @writer. Agents communicate through a file-based queue. Mix Claude and OpenAI agents on one team. Runs 24/7 in the background.

Agent Teams Sequential Handoff Mixed Providers Live Dashboard
N
Concurrent Agents
3
Channels
24/7
Always On
A0

Agent Zero

The Learning Machine
Python

An AI that gets smarter the more you use it. Every solution it finds is saved for next time. 100% transparent: every instruction is visible and editable. Docker-native with project isolation. Creates its own tools on the fly by writing code.

Self-Learning SKILL.md Standard Project Isolation 20+ Providers
20+
AI Providers
100%
Transparent
Docker
Runtime Environment
CC

ClaudeClaw

Pocket Command Center
TypeScript/Node

A personal assistant "operating system" delivered to your phone through Telegram. It runs Claude Code on your own machine and sends the results back in chat. Its standout feature is coordinating a TEAM of specialist agents that talk to each other (text and voice War Room), share a visual 3D "collective brain" (Hive Mind), and can even join real video meetings as avatars. All local: SQLite, no cloud.

Multi-Agent War Room 3D Hive Mind Mission Control Kanban Live Meetings Exfiltration Guard Kill Switches
8
Surfaces
5
Memory Layers
N
Team Agents
HM

Hermes

The Agent That Grows with You
Python

Open-source agent runtime (MIT) from Nous Research: an agent that DOES, not just talks. It combines a reasoning loop (perceive → act → reflect → save), native local persistent memory (SQLite + FTS5), and a dynamic skills system where the agent writes new abilities when it detects a repeated pattern. Local-first, multi-channel, and model-agnostic via OpenRouter (200+ models). The more you use it, the better it knows you.

Autonomous Skills Reflective Loop Self-Curating Memory 24/7 Heartbeat MCP Client Honcho User Modeling
200+
Models via OpenRouter
40+
Native Tools
7
Deploy Backends
AI

AIOS

The Agent Kernel
Python

The AGI Research (Rutgers) project that embeds LLMs inside an operating system layer for agents. It is not a chat wrapper or chain framework: it is a persistent kernel where multiple LLM agents coexist, share models, memory, and tools, and are scheduled like OS processes. The agent talks to the kernel through syscalls (LLMCall, MemoryRead/Write, ToolCall, ContextSwitch) via the Cerebrum SDK. Scientific foundation in COLM/NAACL/ICLR papers.

Agent-as-Process Fairness Scheduler Context Switch Syscalls Agent Hub Kernel + SDK
6
Kernel Modules
5
Published Papers
7+
AI Providers
AO

Awesome OpenClaw

The Knowledge Base
Docs / Guide

It is not a framework—it is the definitive reference library. Cost calculators, 5,700+ community plugins, security advisories, setup guides for 30+ platforms, and real-world use cases. Your research companion when deciding what to build.

Cost Analysis 5,700+ Skills Security Audits 30+ Deploy Options
5.7K+
Listed Skills
6
Documented CVEs
$0-50
Monthly Cost

Key Concepts Explained

These are the ideas that drive every framework. Understanding them helps you choose what matters.

Your AI's “Soul” (Identity System)

Every framework lets you define who your AI is using simple text files. It is like writing a job description for your digital employee.

SOUL.mdPersonality and values
→
AGENTS.mdBehavior rules
→
USER.mdYour preferences
→
MEMORY.mdWhat it remembers
→
Your AI AssistantPersonalized and intelligent

Who uses it: OpenClaw, NanoBot, ZeroClaw, PicoClaw, NanoClaw, Agent Zero (each with minor variations)

The Gateway (Traffic Control Center)

A central hub that receives messages from all your apps (WhatsApp, Slack, Telegram) and routes them to the right AI agent. Think of it as a receptionist who knows which department handles each question.

WhatsAppChannel
TelegramChannel
SlackChannel
→
GATEWAYRoutes and manages
→
Agent AWork tasks
Agent BPersonal tasks

Who uses it: OpenClaw (main), ZeroClaw, PicoClaw, NanoBot, IronClaw

Sandboxing (Security Walls)

When your AI runs code or uses tools, sandboxing keeps it contained. Like giving an employee access to only their office, not the whole building. Different frameworks use different “wall materials.”

Container VMNanoClaw
WASM SandboxIronClaw
DockerAgent Zero
Kernel LandlockZeroClaw
Workspace JailPicoClaw

Tools (What Your AI Can Actually Do)

Tools are your AI's hands and arms. Each framework gives your AI different abilities.

Read/Write FilesAll frameworks
Web SearchAll frameworks
Run CommandsAll frameworks
Browser ControlOC, NC, A0, NB
Scheduled TasksAll frameworks
Send MessagesAll frameworks
Hardware PinsPicoClaw only
Voice Input/OutputOpenClaw, PicoClaw
Visual CanvasOpenClaw only
Create Sub-AgentsOC, PC, NB, TC, A0

Live Multi-Agent Swarm (War Room and Hive)

“Claw” family frameworks usually have one agent that talks with you. ClaudeClaw flips the switch: instead of one, you get a team of specialist agents, each its own Telegram bot, who talk to each other in a live room (the “War Room,” by text or voice) and share a collective brain. Think of a company where each employee logs what they did on a central board—that board is the “Hive Mind,” and ClaudeClaw even renders it as a 3D brain so you can see what the swarm has been up to.

@commsAgent
@opsAgent
@researchAgent
→
WAR ROOMLive meeting (text/voice)
→
HIVE MINDShared 3D brain

Who uses it: ClaudeClaw (War Room in text and voice, 3D Hive Mind). TinyClaw and Agent Zero have teams of agents, but no live meeting or cross-agent visualization.

Reflective Loop (The AI That Creates Its Own Skills)

A regular chat responds and forgets. Hermes runs a closed loop: it perceives (perceive), acts (act), reflects (reflect), and saves (save). The reflection step uses a cheap model just to decide what is worth remembering—so memory curates itself. And there is more: when Hermes notices that you have asked for the same sequence of things three times, it writes a new skill (a draft SKILL.md file) and asks for your approval. In other words, the AI learns a new “trick” through use, without you programming anything.

perceiveReads the message
→
actUses tools
→
reflectCheap model curates memory
→
saveMemory + new skill

Who uses it: Hermes (autonomous skill generation + memory curation during reflect). Agent Zero also learns from past solutions, but does not generate SKILL.md on its own.

Agent as an Operating System Process (LLM Kernel)

All the other frameworks run the agent as a “session” or a “loop.” AIOS takes a different approach: it treats each agent as an operating system process, just like the programs running on your computer. There is a kernel (the core) that embeds the LLM, and a Scheduler that decides which agent talks to the model now—so one slow agent does not block all the others. The agent talks to the kernel through syscalls (explicit requests like “call the LLM,” “read memory,” “use a tool”). And the Context Manager can pause an agent, save its state, and resume it later—exactly as an OS does with processes.

AgentsApplication
→
Cerebrum SDKsyscalls
→
KERNEL + Schedulerarbitrates the LLM
→
ProvidersOpenAI/Claude/...

Who uses it: AIOS (the only one with a fairness scheduler, context switch, and syscalls). Frameworks like LangChain, AutoGen, and CrewAI can run on top of it.

Glossary: The New Comparison Dimensions

Terms that appear in the comparison table, in plain language:

Live War RoomA room where multiple agents meet in real time (text or voice) to discuss a task.
Hive MindAn “event board” that all agents read and write—a team memory, visualized as a 3D brain.
Reflective loopA perceive→act→reflect→save cycle where the AI decides on its own what to remember.
Autonomous skillA skill the AI writes itself when it detects a repeated pattern, for approval.
Scheduler / FairnessDecides which agent uses the model now, sharing access fairly (FIFO / Round-Robin).
Context switchSave an agent's state and resume it later—pause one to give another a turn.
SyscallAn explicit request from the agent to the kernel (call an LLM, read memory, use a tool)—auditable and schedulable.
MCP ClientA connector that plugs in external tools via Model Context Protocol, without writing code.
Exfiltration guardA filter that scans output and redacts secrets (keys, tokens) before sending.
Hot-reload kill switchA flag that turns off a function in seconds, without restarting the process.

Feature Grocery Store

Click items to add them to your cart. Build the ingredient list for your ideal framework.

🧬

Identity and Personality

How your AI presents itself
Soul.md Personality File
Define your AI's personality, values, and communication style in a simple text file. Like writing a character sheet.
OpenClawNanoBotZeroClawPicoClaw
AIEOS Portable Identity Standard
A universal format for AI identity (psychology, linguistics, motivations). Export your AI's personality to any compatible system.
ZeroClaw
Group-Isolated Memory
Each conversation group has its own brain. Your work chat and family chat never mix context or data.
NanoClawIronClaw
Interchangeable Agent Profiles
Prebuilt personas (developer, researcher, writer) that you can switch between. Like changing hats.
Agent ZeroTinyClaw
Dynamic Behavior Rules
Change the AI's behavior in the middle of a conversation. No restart needed. It adapts immediately.
Agent ZeroOpenClaw
Each Agent Is Its Own Telegram Bot
Each specialist agent (comms/content/ops/research) is its own Telegram bot, with its own personality, context window, and avatar, and can be delegated to via @agent: prompt.
ClaudeClaw
🛡

Security and Protection

Protecting your data and systems
WASM Sandbox for Tools
Tools run in tiny isolated containers (WebAssembly). They physically cannot access your files or secrets. Lighter than Docker.
IronClaw
Container VM Isolation
Each conversation runs in its own virtual machine. Complete isolation at the OS level. The strongest barrier between the AI and your system.
NanoClaw
Prompt Injection Defense
Detects and blocks attempts to trick your AI with hidden instructions in web pages or messages. Multi-layer pattern detection.
IronClawHermesClaudeClaw
Secret Leak Detection
Checks tool outputs before they reach the AI to make sure your API keys and passwords aren't accidentally exposed.
IronClaw
Pairing Code Access Control
New users must enter a 6-digit code that you provide before chatting with your AI. Prevents unauthorized access.
OpenClawZeroClawTinyClaw
Encrypted Secret Storage
API keys stored with military-grade encryption (ChaCha20). Even if someone steals the file, they won't be able to read it.
ZeroClawIronClaw
Dangerous Command Blocklist
Automatically blocks commands that could damage your system (delete everything, format disks, restart, etc.)
PicoClawNanoBotZeroClaw
Execution Approval Gates
The AI must ask your permission before running certain commands. Three levels: read-only, supervised, full autonomy.
OpenClawZeroClaw
Output Exfiltration Guard
Scans every outgoing response with regex (API keys, Slack/GitHub tokens, AWS, long hex strings) and redacts secrets before sending it to chat — a barrier against prompt-injection leaks.
ClaudeClaw
Hot-Reload Kill Switches
Flags in .env are re-read every ~1.5s: turn off LLM spawning, dashboard mutations, the scheduler, or War Room in under 2s, without restarting the process, with a rejection counter.
ClaudeClaw
Default-Deny Tool Policy
In the multi-agent room, tools with side effects (Bash/Write/Edit/Skill/MCP) are denied by default and enabled only through opt-in in agent.yaml, with a budget of 8 tools per turn.
ClaudeClaw
OAuth Token Health Monitor
Sends a Telegram alert before the Claude OAuth token expires — essential for daemon deployments (launchd/systemd), where expiration causes silent failure.
ClaudeClaw
Egress Allowlist + Hardened Sandbox
Execution sandbox (firejail/bubblewrap/docker), egress allowlist, and immutable audit log; ~/.ssh ~/.aws blacklist to contain exfiltration.
Hermes
Local-First Data Map
Explicit map of what stays on your hardware (config, SQLite, skills, secrets in env) versus what goes out (prompts to the provider, optional memory to Honcho cloud).
Hermes
💬

Communication Channels

Where your AI lives
WhatsApp Integration
Chat with your AI on WhatsApp. Send messages, images, and voice notes. The most natural choice for everyday business use.
OpenClawNanoClawNanoBotPicoClawZeroClawTinyClawClaudeClawHermes
Telegram Bot
Easiest setup — just one token. Supports rich media, inline buttons, and file sharing. Great for teams.
OpenClawNanoBotPicoClawZeroClawIronClawTinyClawClaudeClawHermes
Discord Bot
AI assistant on your Discord server. Perfect for community management and team channels.
OpenClawPicoClawZeroClawIronClawTinyClawHermes
Slack Integration
Your AI in Slack. No public IP required (Socket Mode). Perfect for workplace automation.
OpenClawNanoBotPicoClawZeroClawIronClawClaudeClawHermes
Voice Wake Word
Say "hey claude" and your AI listens. Always-on voice control like a smart speaker, but private.
OpenClaw
Email (IMAP/SMTP)
The AI reads your email and can reply. Filters spam, summarizes newsletters, and drafts replies.
NanoBotZeroClaw
Web Browser Dashboard
Chat with your AI in a browser. See real-time status, memory, and task progress. No app installation required.
OpenClawIronClawAgent Zero
Multi-Agent War Room
Meeting room with your agent TEAM — in text (/standup, /discuss, ad-hoc rosters) or live voice via Gemini Live, each agent with its own voice, under a second of latency, without Deepgram or Cartesia.
ClaudeClaw
Avatar in a Real Video Meeting
Sends an agent into a real video call (Daily.co/Meet/Zoom) as a participant with a Pika avatar that speaks in real time.
ClaudeClaw
🧠

Memory and Knowledge

How your AI remembers
Hybrid Vector + Keyword Search
Combines "understanding what you mean" (semantics) with "finding exact words" (keywords). The best of both worlds for retrieval.
IronClawZeroClawAgent Zero
Two-Layer Memory System
Layer 1: Quick facts (MEMORY.md). Layer 2: Searchable history log. Simple, but effective.
NanoBotPicoClaw
Solution Memory (Learning from Experience)
The AI automatically saves successful solutions. The next time it faces a similar problem, it will remember what worked before.
Agent Zero
Document Knowledge Base
Upload PDFs, spreadsheets, and documents. The AI can search and analyze them. Your company's knowledge at your fingertips.
Agent ZeroOpenClaw
Automatic Session Compaction
When conversations get too long, it automatically summarizes older parts to keep the AI fast while preserving essential information.
NanoClawIronClaw
3D Collective Brain (Hive Mind)
Every action by any agent becomes an event in a 3D anatomical brain (WebGL/Three.js) with lobes, dots, and synapse arcs — plus a 2D canvas fallback — so you can see what the swarm has been doing.
ClaudeClaw
5-Layer Memory with Decay
Memory extracts facts via Gemini (importance score), stores vector embeddings, searches in 5 ways, consolidates patterns every 30 minutes, and decays or gains salience with use.
ClaudeClaw
Memory Hygiene and Sharing
Periodic review proposes (never writes on its own) what to pin, which conflicts to resolve, and which duplicates to collapse, plus selective promotion of universal facts to the tier shared across agents.
ClaudeClaw
Cross-Agent Activity Log
Event bus (hive_mind table) that every agent writes to and every agent reads from: the whole team can see what each agent did in the last 24 hours within the memory context.
ClaudeClaw
Self-Curating Memory in the Reflect Step
Perceive->act->reflect->save loop: an inexpensive model (<1k tokens) decides what is worth remembering and curates memory on its own, instead of having you dictate everything.
Hermes
SQLite FTS5 / BM25 Recall (No Embeddings)
Persistent local memory in 3 layers (conversations with TTL, facts without TTL, skills) with BM25 full-text search — no embeddings, offline, recall in milliseconds.
HermesINTELECTO
User Modeling with Honcho
User representations engine (dialectic agent) that builds an evolving model of who you are with each conversation; runs locally or in the cloud.
Hermes
Semantic File System (LSFS)
Storage indexed by embeddings: find files by meaning in natural language ("the PDF about AIOS from last week"), not by path. ICLR 2025 paper; complements the FS, doesn't replace it.
AIOS
Curated Agentic Memory (A-MEM)
Memory where the agent itself decides what to keep, compresses redundant information, and indexes what can be searched — counters context bloat in long-running agents. An evolution of the Memory Manager.
AIOS
Memory vs. Storage (RAM × Disk)
Explicit kernel distinction: the Memory Manager is a fast per-agent cache that disappears on restart; the Storage Manager persists on disk and can be shared across agents. Don't confuse the two.
AIOS
⚙

Automation and Scheduling

Work while you sleep
Cron Scheduling
Run tasks on a schedule: "every Monday at 9 a.m., send me a briefing." Works like a reliable alarm clock for your AI.
OpenClawNanoClawNanoBotPicoClawZeroClawTinyClawIronClaw
Heartbeat (Periodic Checks)
The AI wakes up every 30 minutes to check whether anything needs attention. Proactive, not just reactive.
OpenClawPicoClawNanoBotIronClawZeroClawHermes
Browser Automation
The AI controls a browser: fills out forms, clicks buttons, extracts data, and takes screenshots. Automates web-based work.
OpenClawNanoClawAgent ZeroTinyClaw
Webhook Triggers
External services (Zapier, n8n, Shopify) can trigger your AI via URL. Connects to any automation ecosystem.
OpenClawZeroClawIronClaw
Background Sub-Agents
Create auxiliary AI workers for long tasks. The main agent stays responsive while the workers handle the heavy lifting in the background.
PicoClawNanoBotAgent ZeroTinyClawHermes
Agent Team Collaboration
Multiple specialized agents (@coder, @reviewer, @writer) automatically hand work off to one another. Like a small AI company.
TinyClawNanoClawAgent Zero
Mission Control (Kanban by Agent)
Kanban board with one column per agent, tasks auto-assigned by Gemini, drag and drop to reassign, and a history drawer showing everything completed.
ClaudeClaw
Acceptance Checks (Verifiable Success)
A scheduled task counts as successful only if its output contains a defined marker — a "turn returned" is no longer mistaken for an "objective achieved."
ClaudeClaw
Proactive Heartbeat Agent
Built-in scheduler (APScheduler) with zombie detection, reclaim, and retries: briefings, reminders, and proactive check-ins that make the agent feel alive 24/7.
Hermes
Goal Function (Northstar)
Instead of question->answer, you give the agent a goal and it uses a budget of turns (~20) or generates 4-10 actions with a progress bar until it reaches the objective.
Hermes
Parallel Sub-Agents (Team)
Orchestrator launches N sub-agents with fresh context that work in parallel as a team and deliver a report (1 hour instead of 6).
Hermes
Real Computer Actions
Real actions on your PC: browser vision with Chrome DevTools, visual screen reading, and real cursor movements (fused) — can be enabled in tools, with care.
Hermes
Computer Use via VM + MCP (LiteCUA)
Exposes the whole computer as MCP tools (screenshot/click/type) inside a sandboxed VM (KVM/Firecracker). Perceive-decide-act loop with a multimodal LLM to operate GUIs without an API.
AIOS
Multi-Agent Fan-Out / Fan-In
Coordinator splits the task into N subtasks, N agents process them in parallel (scheduled by the Scheduler), each saves its result to Storage, and the coordinator aggregates them when all are done.
AIOS
🔗

Integrations and Protocols

Connecting to the world
MCP (Model Context Protocol)
Universal standard for connecting AI to external tools. One protocol, thousands of integrations. The "USB" for AI tools.
OpenClawNanoBotIronClawAgent ZeroClaudeClawHermes
Skills / Plugin System
Install new capabilities like apps on your phone. "Install weather skill" or "install GitHub skill." No coding required.
OpenClawPicoClawNanoClawAgent ZeroTinyClawHermesClaudeClaw
Plugin SDK (Build Your Own)
A developer kit for creating new channels, tools, and memory backends. Build custom integrations for your specific business.
OpenClawIronClaw
Multi-Provider AI Failover
If Claude goes down, automatically switch to GPT. If GPT is slow, try Gemini or OpenRouter. With OpenRouter, you get 100+ models for automatic fallback with a single key. Never lose service.
IronClawOpenClawZeroClawOpenRouterHermes
OpenRouter — 100+ Models, 1 Key
Access Claude, GPT-4, Gemini, Mistral, DeepSeek, Llama, and 100+ more models with a single API key. Switch models without changing code. Ideal as the main provider with Ollama as a local fallback.
OpenRouterINTELECTONanoBotHermesClaudeClaw
Task-Based Model Selection
Use Claude Sonnet for complex reasoning, Haiku for fast, inexpensive responses, and DeepSeek R1 for code analysis. Each task type uses the most efficient model — full control over cost and quality.
OpenRouterZeroClawIronClawAgent Zero
Local LLM Support (Ollama)
Run AI models on your own computer. Zero API cost. Full privacy. No internet required. Use with OpenRouter: cloud when you need power, local when you need privacy.
OpenClawZeroClawPicoClawAgent ZeroNanoBotINTELECTOHermesAIOS
Specialized Media Providers (fal.ai, Kie.ai)
For images, sound, and video, use specialized providers: fal.ai (ultrafast image generation, Flux, SDXL, video with Kling/CogVideoX), Kie.ai (high-quality video and audio). Text LLMs are weak at media — these providers are the right choice for content creation.
fal.aiKie.aiOpenClaw
Hardware / IoT Control
Control physical devices: lights, sensors, motors. AI can interact with the real world through GPIO pins.
PicoClaw
Normalized Provider Engine (ACP)
Single engine layer with adapters for Claude SDK, native OpenRouter, and ACP (OpenCode/Gemini CLI/Codex/custom), with separate sessions per provider to keep histories from crossing.
ClaudeClaw
Toolsets On/Off
40+ native tools grouped into on/off toolsets in config.yaml; a rule of no more than ~25 active tools preserves model accuracy.
Hermes
Decorator-Based Tool Gateway
Turn any Python function into a tool by decorating it with @hermes.tool; the schema is inferred from type hints — imperative logic without packaging an MCP server.
Hermes
Build Your Own MCP Server
Create your own MCP server in Python (FastMCP) or Node (@modelcontextprotocol/sdk) with OAuth/JWT auth and publish it via Docker/npm/pip.
Hermes
Core Multi-LLM Routing by Task
Multiple LLM Cores run in parallel (1 per provider/model); the agent requests "model X" via syscall and the kernel routes it. Cheap model for classification, top model for reasoning — no refactor needed.
AIOS
🧰

Built-In Skills and Ready-to-Use Tools

What's ready to use out of the box
Apple Notes Management
Create, view, edit, delete, and search Apple Notes directly from your AI assistant on macOS.
OpenClaw
Apple Reminders
Create, list, edit, and complete reminders in Apple Reminders. Your AI manages your task list.
OpenClaw
Notion Pages and Databases
Create and manage Notion pages, databases, and blocks. AI-powered workspace management.
OpenClaw
Obsidian Vault Automation
Work with Obsidian vaults and automate note management in plain Markdown.
OpenClaw
Trello Board Management
Manage Trello boards, lists, and cards via the API. AI takes care of your project boards.
OpenClaw
Things 3 Task Manager
Add, update, and search tasks in the Things 3 app on macOS.
OpenClaw
Bear Notes
Create, search, and manage notes in the Bear note-taking app.
OpenClaw
Google Workspace Suite (Gmail, Calendar, Drive, Sheets, Docs, Slides)
Full Google Workspace integration: send emails, manage your calendar, read and write documents, create spreadsheets, and build presentations.
OpenClawIronClaw
Feishu / Lark Suite (Docs, Drive, Wiki, Permissions)
Full Feishu/Lark integration: documents, cloud storage, wiki, and permission management for Asia-Pacific teams.
OpenClaw
GitHub (Issues, PRs, CI, API)
Complete GitHub workflow: manage issues, review pull requests, trigger CI runs, and query the API. Manage code through chat.
OpenClawNanoBotPicoClawIronClawZeroClaw
Automated PR Review + Preparation + Merge
Three-step pull request workflow: AI reviews the code, prepares the changes, and merges after validation. Complete code review pipeline.
OpenClaw
X / Twitter Posting
Post tweets, like, reply, retweet, and quote through your AI assistant.
NanoClaw
Gmail Reading/Sending (Standalone)
Read, send, and manage Gmail. Works as a tool (on demand) or as a channel (emails trigger the AI).
NanoClawIronClaw
iMessage / SMS on macOS
Send and manage iMessages and SMS with chat history and message monitoring on macOS.
OpenClaw
Proactive User Messages
AI sends you messages without waiting for your prompt. Alerts, reminders, and status updates sent to your chat.
TinyClawAgent Zero
Whisper Speech-to-Text
Convert voice recordings to text. Works locally (no API key) or through the OpenAI Whisper API.
OpenClawNanoClaw
Text-to-Speech (ElevenLabs + Local)
Convert text into natural speech. In the cloud through ElevenLabs or offline through sherpa-onnx. Your AI talks back.
OpenClaw
AI Image Generation
Generate images through the OpenAI API or Google Gemini. Supports inpainting, masks, and batch generation.
OpenClawTinyClaw
Video Frame Extraction
Extract frames or short clips from videos using ffmpeg. AI can analyze video content.
OpenClaw
Spotify Player Control
Control Spotify playback and search for music through your AI assistant.
OpenClaw
URL / Video / Podcast Summarizer
Summarize web pages, YouTube videos, podcasts, and local files. Get the essentials without reading or watching everything.
OpenClawNanoBotPicoClaw
Blog and RSS Feed Monitor
Monitor blogs and RSS/Atom feeds for new updates. Get notified when your favorite sources publish.
OpenClaw
Weather Forecast (No API Key)
Get current weather and forecasts using free services. No API key required.
OpenClawNanoBotPicoClaw
Google Places Search
Search for businesses, restaurants, and places. Get details, reviews, and ratings.
OpenClaw
Document Q&A (PDF, Spreadsheet, HTML)
Upload documents and ask questions about them. AI extracts answers from your files.
Agent Zero
Philips Hue Light Control
Control your Philips Hue lights and scenes with AI commands. "Dim the living room to 30%."
OpenClaw
Sonos Speaker Control
Control Sonos speakers: playback, volume, grouping, and discovery.
OpenClaw
Eight Sleep Pod Mattress Control
Adjust your smart mattress temperature, set alarms, and manage sleep schedules.
OpenClaw
I2C / SPI Hardware Bus Control
Read sensors and control hardware peripherals on embedded boards. AI communicates with physical devices.
PicoClaw
Security Camera Captures
Capture frames and video clips from RTSP/ONVIF cameras. AI monitors your security feeds.
OpenClaw
Remote Tmux Session Control
Send keystrokes to terminal sessions and retrieve output. AI operates CLI tools interactively.
OpenClawNanoBotPicoClaw
Coding Agent Orchestration
Run Codex CLI, Claude Code, or other coding agents programmatically. AI manages AI coders.
OpenClaw
Composio (1000+ App Connector)
One-click OAuth access to 1000+ apps: Gmail, Notion, GitHub, Slack, and more through Composio.
ZeroClaw
Okta Identity Management
Manage users, groups, and authentication with the Okta enterprise identity platform.
IronClaw
Store / Retrieve / Forget Memory
Dedicated tools to save, search, and delete memories. AI manages its own knowledge base.
ZeroClawIronClawAgent Zero
Git Operations (Status, Diff, Log, Commit)
Structured Git operations with parsed JSON output. AI manages your code repositories.
ZeroClaw
Screenshot and Visual Analysis
Capture screens, read image metadata, and analyze visual content. AI can see your screen.
ZeroClawAgent Zero
Background Job and Routine Manager
Create, list, check the status of, and cancel background jobs. Schedule routines with cron, webhooks, or event triggers.
IronClaw
Extension Marketplace (Search/Install/Authenticate)
Browse, install, authenticate, and activate extensions from a marketplace. Expand your AI on the spot.
IronClawOpenClaw
Food Delivery Ordering and Tracking
Repeat food delivery orders and track order status/ETA. Order dinner through chat.
OpenClaw
Skill Creator (Build Your Own)
Framework for creating and packaging new skills with scripts, references, and assets. Expand your AI's capabilities.
OpenClawNanoBotPicoClawTinyClaw
Real-Time Behavior Adjustment
Modify and update AI behavior rules mid-conversation. AI rewrites its own instructions on the spot.
Agent Zero
Agent-to-Agent Communication (A2A)
One Agent Zero instance talks to another. Distributed workflows across multiple isolated agents.
Agent Zero
SearXNG Private Web Search
Self-hosted web search engine. No tracking, no API keys. Complete search privacy.
Agent Zero
Prebuilt Agent Profiles (Developer, Researcher, Hacker)
Switch your AI's persona instantly. Developer mode for coding, Researcher mode for analysis, and more.
Agent Zero
Nostr Encrypted Messages
Connect to the decentralized Nostr protocol for encrypted direct messages. Native Web3 communication.
OpenClaw
Mintlify Documentation Builder
Build and maintain documentation websites from Markdown files. AI writes your docs site.
OpenClaw
Natural Language PDF Editing
Edit PDFs by describing what you want to change. "Move the logo to the top-right corner and change the date."
OpenClaw
1Password Secret Retrieval
Securely retrieve credentials and secrets from your 1Password vault via CLI.
OpenClaw
Skills Auto-Registered as /commands
Any skill with user_invocable:true automatically becomes a /command in the Telegram menu (setMyCommands), with no code changes — just drop in the skill folder.
ClaudeClaw
Autonomous Skill Generation
The agent detects a repeated workflow (>=3x) during the reflect step and writes a SKILL.md draft for you to approve — skills born from use, without programming.
Hermes
Portable Skills (agentskills.io)
Skills as self-contained folders with SKILL.md (YAML frontmatter + Markdown), an open standard portable across Hermes, Claude Code, and Codex.
Hermes
Skill Composition and State Machines
Small skills compose through hermes.invoke() (a graph, not a monolith), and N-step workflows use @hermes.step with automatic checkpointing.
Hermes
Agent Hub (the "PyPI for Agents")
Registry for publishing versioned agents (semver) and installing them with one command (cerebrum hub publish/search/install/run). Agent reuse moves out of the lab.
AIOS
🏗

Architecture Patterns

How to structure your framework
Trait-Based Modularity
Each component is defined by a contract. Swap implementations without touching other code. The cleanest extensibility pattern.
ZeroClawIronClaw
Message Bus Architecture
Channels and agents communicate through a central message highway. Clean separation, easy to add new channels.
NanoBot
File-Based Message Queue
Messages are stored as files that move through directories (receiving > processing > sending). Simple, reliable, no database.
TinyClaw
WebSocket Gateway Hub
Central server that all channels connect to through real-time WebSockets. The "control tower" pattern.
OpenClawIronClaw
Dual Database Backend
Use PostgreSQL for production and SQLite for development. Same code, switch with a configuration flag. The best of both worlds.
IronClaw
Project-Based Workspace Isolation
Separate workspaces by client/project. Each has its own memory, secrets, and instructions. No data mixing.
Agent ZeroNanoClaw
Single-Binary Deployment
One file. No dependencies. Copy it anywhere and it works. The simplest deployment story possible.
PicoClawZeroClaw
"Computer as a Tool" Paradigm
Instead of prebuilt integrations, AI writes code on the spot to get things done. Infinitely flexible, no maintenance required.
Agent Zero
Intelligent Model Routing
A complexity classifier sends trivial messages ("ok", "thanks") to a lightweight model and heavy tasks to a full model, saving tokens and time.
ClaudeClaw
Unified Message Gateway
One gateway normalizes CLI, Discord, Slack, WhatsApp, HTTP, and cron into the same Message object — one brain, all the mouths, agent decoupled from the channel.
Hermes
Multi-Backend Deployment (7 backends)
Local, Docker, SSH, Modal, Vercel Sandbox, Singularity/Daytona, and AWS Bedrock AgentCore — from an old laptop running 24/7 to a Firecracker microVM per session.
Hermes
Request Trace (6 hops)
HERMES_TRACE=1 exposes the end-to-end path (webhook -> gateway -> memory FTS5 -> LLM -> tool exec -> response+write) with P50/P95/P99 latencies.
Hermes
100% Declarative Config (config.yaml)
Provider, model, toolsets, MCPs, channels, cron, and system prompts in one versioned YAML file, with dev/prod profiles and ${VAR} for secrets.
Hermes
Agent-as-Process (Fairness Scheduler)
Multiple LLM agents become processes scheduled by a Scheduler with fairness — instead of one long-running agent blocking everyone, the kernel shares access to the LLM (FIFO for 1–2 agents, Round-Robin for 3+).
AIOS
LLM Kernel with Syscall Interface
The LLM is embedded as the kernel core, and the agent communicates through syscalls (LLMCall, MemoryRead/Write, ToolCall, ContextSwitch). Each action becomes an explicit, auditable, schedulable request — the agent's "strace".
AIOS
Context Switch (Snapshot / Restore / Migrate)
Save an agent's full state (memory, plan position, working set) and restore it later — lets you pause a long-running agent to give another a turn, or migrate the agent to another kernel.
AIOS
Kernel + SDK Separation
Two repositories mirroring Linux kernel × glibc: the kernel manages resources (the operator works here), the SDK builds agents (the developer works here). Enables Local/Remote modes and the Agent Hub.
AIOS
Adapter Layer (frameworks run on top)
Execution layer beneath the frameworks: replaces direct LLM calls with a syscall (adapter pattern), so any framework (LangChain/AutoGen/CrewAI/MetaGPT/OpenAGI) inherits scheduling, fairness, and persistence — incremental migration (strangler).
AIOS

Side-by-Side Comparison

Feature matrix across all frameworks. Green = supported, yellow = partial, gray = unavailable.

Feature OpenClaw ZeroClaw NanoClaw NanoBot PicoClaw IronClaw TinyClaw Agent Zero ClaudeClaw Hermes AIOS
LanguageTypeScriptRustTypeScriptPythonGoRustTS/BashPythonTypeScriptPythonPython
WhatsAppYesYesPrimaryYesYesPlannedYes-ExperimentalYes-
TelegramYesYesVia skillYesYesYesYes-PrimaryYes-
DiscordYesYes-YesYesYesYes--Yes-
SlackYesYesVia skillYesYesYes--YesYes-
Web InterfaceYes----Yes-YesDashboardTUIWeb UI
Voice ControlWake Word---Via Groq---War Room voiceTTS/STT-
Canvas / VisualizationCanvas-------3D Brain--
Multi-AgentYesConfigSwarmSpawnSpawnParallelTeamsHierarchyTeam (War Room)Sub-agentsProcesses
Cron SchedulingYesYesYesYesYesYesYesVia codeYesAPSchedulerVia code
HeartbeatYesYes-YesYesYesYes-YesZombie detection-
Browser ControlCDPWebDriverChromium--VisionCLI toolVision-Chrome DevToolsLiteCUA/VM
MCP SupportYes--Yes-Yes-YesYesFirst-class clientVia LiteCUA
Skills/PluginsSDK + 5.7KTOMLClaude CodeMarkdownMarkdownWASMFolderSKILL.mdAuto-/commandsAuto-generatedAgent Hub
Sandbox TypeApprovalLandlockVM ContainerWorkspaceWorkspaceWASMDirectory per agentDockerTool policyfirejail/bwrapKVM/Firecracker VM
Memory SystemEmbeddingsHybrid FTS+VecCLAUDE.md2 Layers2 LayersHybrid FTS+VecPer agentVector+Solutions5 Layers+DecayFTS5/BM25A-MEM+LSFS
Local LLMOllamaOllama+vLLM-Ollama+vLLMOllama+vLLMOllama-Ollama+LM Studio-Ollama+vLLM+llama.cppHuggingFace+vLLM
AI Providers6+22+1 (Claude)13+7+NEAR AI220+8 engines14+ (200+ models)7+
Encrypted SecretsKeychainChaCha20-chmod 600-Keychain-secrets.envAES-256-GCMenv varsconfig.yaml
RAM Usage~1GB<5MB~200MB~100MB<10MB~50MB~300MB~500MB---
IoT/Hardware----GPIO/I2C/SPI------
Mobile AppsiOS+Android-------Via Telegram--
Live War Room (text/voice)--------Text + VoiceSub-agents-
Cross-Agent Visualization (brain)--------3D Hive Mind--
Autonomous Skill Generation-------Creates tools-SKILL.md draft-
Self-Curating Memory / Decay-------Solutions5 layers+decayReflect-stepA-MEM
Agent as OS Process / Scheduler----------FIFO/Round-Robin
Context Switch / Preemption----------Snapshot/Restore
Declarative MCP ClientYes--Yes-Yes-YesYesstdio + SSELiteCUA
Output Exfiltration Guard-----Leak detection--Outbound regexEgress allowlist-

Architecture Patterns

How each framework is structured internally. These are the blueprints you would follow.

OC

OpenClaw: Hub Gateway

CHANNELS AGENTS WhatsApp Telegram Slack Agent A Agent B Discord iMessage WebChat (Work) (Personal) \ | / \ / \ | / \ / v v v v v +------------------+ +------------------+ | GATEWAY |------| SESSION STORE | | (WebSocket Hub) | | (JSONL files) | +------------------+ +------------------+ | +--------+--------+ | | | TOOLS CANVAS VOICE Browser Live UI Wake Word Files Diagrams TTS/STT Shell React ElevenLabs
ZC

ZeroClaw: Trait Contracts

config.toml defines which implementations to use: +-----------+ +-----------+ +----------+ | Provider | | Channel | | Memory | | (trait) | | (trait) | | (trait) | +-----------+ +-----------+ +----------+ ^ ^ ^ | | | +----+----+ +-----+-----+ +----+----+ |OpenAI | |Telegram | |SQLite | |Claude | |Discord | |Markdown | |Ollama | |Slack | |None | |Gemini | |WhatsApp | +---------+ |22 more..| |Email | +---------+ |Webhook | +-----------+ Swap ANY piece without touching agent code
NC

NanoClaw: Container Isolation

HOST (macOS/Linux) +--------------------------------------------+ | WhatsApp Connection (Baileys) | | SQLite Message Store | | Message Polling Loop | | Task Scheduler | +--------------------------------------------+ | | | +-- Container --+ +-- Container --+ +-- Container --+ | Work Group | | Family Group | | Admin Chat | | Claude SDK | | Claude SDK | | Claude SDK | | Own CLAUDE.md | | Own CLAUDE.md | | Full access | | Sandboxed FS | | Sandboxed FS | | All groups | +---------------+ +---------------+ +--------------+ Each group = isolated brain. Cannot see each other.
TC

TinyClaw: Agent Teams

YOU (via Discord / Telegram / WhatsApp) | v +------------------+ | Message Queue | incoming/ -> processing/ -> outgoing/ | (File-Based) | Each agent picks from its own inbox +------------------+ | +----+----+----+----+ | | | @coder @reviewer @writer Claude OpenAI Claude Opus GPT-5 Sonnet | ^ ^ | | | +---mention---------+ Agents hand off to each other "[@reviewer: check this code]" Parallel processing. Sequential per-agent.
IC

IronClaw: Zero-Trust Security

Messages In Security Layers CLI Slack Telegram | | v +----v----+ +--------------------+ | Channel | | Prompt Injection | | Manager |--->| Pattern Detection | +---------+ +--------------------+ | | +----v----+ +--------------------+ | Job | | WASM Sandbox | | Scheduler--->| Capability Allowlist| | (5+ // | | Rate Limiting | | jobs) | | Credential Inject | +---------+ +--------------------+ | | +----v----+ +--------------------+ | LLM | | Leak Detector | | NEAR AI | | Scans outputs for | | +Ollama | | leaked secrets | +---------+ +--------------------+
A0

Agent Zero: Learning Loop

You ask a question | v +-----------+ +-----------+ | Agent 0 |---->| Memory | | (Main) |<----| Search | "Have I solved this before?" +-----------+ +-----------+ | +----+----+ | | Sub-Agent Sub-Agent Delegation for (Research) (Code) complex tasks | | +----+----+ | +----v----+ +-----------+ | Solution |---->| Memory | | Found! | | SAVE | "Remember for next time" +---------+ +-----------+ Gets smarter with every interaction
CC

ClaudeClaw: Local Swarm + Hive Bus

YOU (Telegram / Dashboard / War Room voice) | v +----------------------+ | Per-Agent Telegram Bots | @comms @content @ops @research +----------------------+ | | | Agent A Agent B Agent C delegate_to_agent (@agent:) \ | / \ | / WAR ROOM (text + Gemini Live voice) v v v +------------------------------+ | HIVE BUS (hive_mind table) |---> 3D Brain (Three.js) | shared event bus | cross-agent visualization +------------------------------+ | | Single SQLite Runtime Guard store/*.db kill-switches + tool-policy 5-layer memory + exfiltration guard (output) N agents, 1 machine, 1 shared brain
HM

Hermes: Reflective Loop + Autonomous Skills

CLI Discord Slack WhatsApp HTTP cron \ | | | | / v v v v v v +---------------------------+ | GATEWAY (normalizes -> Message)| one brain, N mouths +---------------------------+ | v AGENT LOOP +---------------------------------------+ | perceive -> act -> reflect -> save | | (cheap model in reflect)| +---------------------------------------+ | reflect detects pattern >=3x | heals v v +-----------------+ +------------------+ | Auto-Generated Skill | | SQLite Memory | | SKILL.md (draft)| | FTS5/BM25 3 layers | +-----------------+ +------------------+ The agent improves itself (skills + memory)
AI

AIOS: Agent-as-Process / LLM Kernel

APPLICATION Agent A Agent B Agent C | | | ------------------------------------------------- CEREBRUM SDK Base agent + syscall wrappers + @tool | (LLMCall, MemoryRead/Write, | ToolCall, ContextSwitch) ------------------------------------------------- AIOS KERNEL +----------------------------------+ | Scheduler (FIFO / Round-Robin) | | LLM Core(s) | Memory | Storage | | Tool Manager | Context Manager | | (snapshot/restore) | +----------------------------------+ ------------------------------------------------- OS / PROVIDERS OpenAI Anthropic Gemini vLLM ... Each agent = scheduled process. LangChain/AutoGen run on top.

Verdicts: Best for Each Use Case

Quick guide: which framework to choose based on what matters most to you.

"I want the most complete solution"

Complete, polished, with voice, canvas, mobile apps, and 5,700+ plugins. The "iPhone" approach.

Choose: OpenClaw

"I want maximum efficiency"

Smallest memory footprint, fastest startup, runs on $10 hardware. The "sports car" approach.

Choose: ZeroClaw (Rust) or PicoClaw (Go)

"I want to understand every line of code"

Small enough to read all at once. No hidden complexity. The "open book" approach.

Choose: NanoClaw (5.2K lines) or NanoBot (4K lines)

"Security is my #1 priority"

WASM sandboxing, prompt injection defense, leak detection, zero-trust. The "fortress" approach.

Choose: IronClaw

"I want AI teams that collaborate"

Multiple specialized agents handing work off to one another. The "small business" approach.

Choose: TinyClaw or Agent Zero

"I want an AI that learns over time"

Remembers solutions, builds knowledge, gets smarter. The "growing brain" approach.

Choose: Agent Zero

"I mainly use WhatsApp for business"

WhatsApp-first design with group isolation. Simple, secure, purpose-built.

Choose: NanoClaw

"I want to control IoT devices"

Direct control of hardware pins (GPIO, I2C, SPI). AI meets the physical world.

Choose: PicoClaw

"I want the widest choice of AI providers"

Supports 20+ AI providers, easy switching between them, use local models for free.

Choose: ZeroClaw (22+) or Agent Zero (20+)

"I use Python and want to extend it easily"

Python code with clean interfaces for adding channels, tools, and providers.

Choose: NanoBot or Agent Zero

"I need help deciding / researching"

Comprehensive knowledge base with cost calculators, security audits, and 5,700+ plugin examples.

Choose: Awesome OpenClaw (the resource guide)

"I want a TEAM of agents working live"

Multiple specialist agents that meet in real time (text and voice), share a collective brain you can visualize in 3D, and can even join video meetings. The "headquarters" approach.

Choose: ClaudeClaw

"I want an AI that improves itself"

Creates its own skills when it detects repeated patterns and heals its own memory during the reflect step. Local-first, model-agnostic, proactive 24/7. The "agent that grows with you" approach.

Choose: Hermes

"I need many concurrent agents, like an OS"

Schedules agents as processes, with a fairness Scheduler, context switching, and auditable syscalls. Existing frameworks run underneath. The "agent operating system" approach.

Choose: AIOS

"I want to build MY OWN custom framework"

Choose the best ideas from all the repositories. Use this page as your shopping list!

Choose: Mix and match from all of them

Your Framework Ingredients

Click grocery store items to add them here.