Skip to main content
NanoClaw Pro is built on a set of clear principles that prioritize simplicity, security, and individual customization over feature bloat and universal compatibility.

​
Core Principles

The entire codebase should be something you can read and understand.What this means:
  • One Node.js process, not a microservices architecture
  • A handful of source files, not hundreds of modules
  • No complex abstraction layers
  • No message queues or orchestration systems
Why it matters: If you want to understand the full NanoClaw codebase, just ask Claude Code to walk you through it. You can actually comprehend what’s running on your machine.Compare to alternatives: OpenClaw has nearly half a million lines of code, 53 config files, and 70+ dependencies. NanoClaw provides the same core functionality in a codebase you can realistically audit.
True security comes from OS-level isolation, not application-level permission checks.What this means:
  • Agents run in Linux containers (Apple Container on macOS, or Docker)
  • They can only see what’s explicitly mounted
  • Bash access is safe because commands run inside the container
  • Filesystem isolation prevents unauthorized access
Why it matters: You wouldn’t have been able to sleep if you had given complex software you didn’t understand full access to your life. Container isolation means even if something goes wrong, the blast radius is limited.Compare to alternatives: OpenClaw uses application-level security (allowlists, pairing codes) where everything runs in one Node process with shared memory. NanoClaw isolates agents at the OS level.
NanoClaw isn’t a monolithic framework; it’s software that fits each user’s exact needs.What this means:
  • Not a platform trying to serve everyone
  • Fork the repo and customize it for your specific use case
  • Add only the integrations you actually want
  • Your fork becomes bespoke software that does exactly what you need
Why it matters: Instead of becoming bloatware with every possible integration, NanoClaw is designed to be personalized. You make your own fork and have Claude Code modify it to match your needs.Example: If you use WhatsApp and Email, your fork supports WhatsApp and Email. If you don’t use Telegram, you don’t add Telegram support. Simple.
No configuration sprawl. Want different behavior? Modify the code.What this means:
  • Very minimal things (like trigger word) are in config files
  • Everything else: change the code to do what you want
  • No YAML files with hundreds of options
  • No complex configuration hierarchies
Why it matters: The codebase is small enough that making changes is safe and practical. Configuration files create complexity and edge cases. Code is explicit and auditable.Example: Want to change how the assistant greets you? Don’t look for a greeting_template config option. Just modify the code that generates greetings.
The development experience assumes you have Claude Code as a collaborator.What this means:
  • No installation wizard—Claude Code guides setup
  • No monitoring dashboard—ask Claude what’s happening
  • No elaborate logging UIs—Claude reads the logs
  • No debugging tools—describe the problem and Claude fixes it
Why it matters: Traditional software needs to be self-documenting and self-debugging because it assumes a human will maintain it manually. NanoClaw assumes Claude Code is always available to help.Example: When something breaks, you don’t need to learn a debugging interface. You say “Why isn’t the scheduler running?” and Claude Code investigates.
Instead of adding features to the codebase, contributors submit skills that transform your fork.What this means:
  • Don’t create a PR that adds Telegram support alongside WhatsApp
  • Instead, contribute a skill file (e.g., /add-telegram) that teaches Claude Code how to add Telegram
  • Users run the skill on their fork and get clean code
Why it matters: You end up with exactly what you need, not a bloated system trying to support every use case. Each user’s fork stays clean and focused.Available skills:
  • /add-whatsapp - Add WhatsApp as a channel
  • /add-telegram - Add Telegram as a channel
  • /add-slack - Add Slack as a channel
  • /add-discord - Add Discord as a channel
  • /add-gmail - Add Gmail integration
  • And many more…
Use the highest-quality agent framework and the most capable model.What this means:
  • NanoClaw runs on the Claude Agent SDK
  • You’re running Claude Code directly, not a wrapper
  • Claude’s coding and problem-solving capabilities allow it to modify and expand NanoClaw
Why it matters: The better the underlying model, the more NanoClaw can do. Claude Code is highly capable and can tailor the system to each user.Flexibility: You can also use third-party or open-source models. Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN in your .env file to point to any Claude API-compatible endpoint.

​
Why This Philosophy Exists

NanoClaw is a reaction to the complexity and security risks of larger AI assistant projects.

​
The Problem with OpenClaw

OpenClaw is an impressive project, but:
  • Nearly half a million lines of code - impossible to realistically understand
  • 53 config files - configuration sprawl
  • 70+ dependencies - large attack surface
  • Application-level security - allowlists and permission checks, not true OS isolation
  • Shared memory - everything runs in one Node process
You kind of just yolo it when you run OpenClaw. You can’t really audit what it’s doing.

​
The NanoClaw Alternative

NanoClaw provides the same core functionality:
  • Codebase small enough to understand - one process, handful of files
  • True OS-level isolation - agents run in Linux containers
  • Focused feature set - only what you actually need
  • Easy to audit - you can read and comprehend the entire codebase
NanoClaw isn’t trying to replace OpenClaw for everyone. It’s for people who value understanding their software and want true security through isolation.

​
Practical Implications

​
For Users

  • Fork and customize: Clone the repo, make it yours
  • Ask Claude Code for help: Setup, debugging, modifications—all guided by AI
  • Add only what you need: Use skills to add channels and integrations selectively
  • Audit your code: Actually read and understand what’s running

​
For Contributors

  • Don’t add features: Add skills instead
  • Keep the core small: The main codebase should stay minimal
  • Write skills: Teach Claude Code how to transform a user’s fork
  • Document through code: Make code readable, assume Claude Code is available for explanation

​
For Security

  • Container isolation limits risk: Even if something goes wrong, agents can only access mounted directories
  • Small codebase is auditable: You can actually review what’s running
  • Explicit mounts: Each group declares exactly what it can access
  • No shared memory: Agents run in separate containers

​
Living Philosophy

This philosophy isn’t static. As the project evolves, the principles remain:
  1. Keep the core small
  2. Use containers for true isolation
  3. Customize through skills, not config
  4. Assume Claude Code is your collaborator
  5. Build for individual users, not generic use cases

Join the Community

Questions? Ideas? Join the NanoClaw Discord to discuss the philosophy and share your customizations.

Build docs developers (and LLMs) love

Get started for freeTalk to us