A modular framework for building massively parallel agentic systems

| Documentation | Why Wasmind | FAQ |

This is a short demo of the wasmind_cli -- a cli application built with Wasmind. Note that the prompts used are not very refined. This is just an example to show what can be built with Wasmind.

NOTE: Wasmind is an early stage expirmental framework. Please report any bugs or issues you find.

Want to try Wasmind? Check out wasmind_cli - a CLI application built with Wasmind that demonstrates actor-based AI development workflows (including Claude Code-style interactions).

Want to build with Wasmind? Continue reading or jump to the Developer Guide to start building your own actors and systems.

Wasmind is an actor-based system for building AI agent workflows. Instead of monolithic AI applications, you compose small, focused actors that each handle specific capabilities.

Actors are WebAssembly components - they can do anything, but typically fall into three categories:

• Assistant actors - manage LLM interactions and conversation flow
• Tool actors - provide capabilities like file manipulation, code execution, and web access
• Coordination actors - enable complex multi-agent workflows and delegation

Actors communicate through structured message passing, enabling coordination at any scale - from simple workflows to networks of thousands of coordinated agents.

Important: Wasmind is NOT a Claude Code alternative—it's the infrastructure that makes projects like Claude Code possible. Our wasmind_cli demonstrates how to build Claude Code-style interactions using Wasmind's coordination primitives.

A simplified architecture diagram showing the Wasmind orchestrator coordinating multiple agents through message passing. Each agent contains different types of actors (Assistant, Tool, etc.) that handle specific capabilities.

Wasmind can be used for anything but is best at building massively parallel multi-agent systems. Start with individual actors, compose them through configuration, scale to thousands - all without writing code.

Current Demos:

• Delegation Network - Hierarchical multi-agent coordination system for spawning and managing specialized AI agents (think Claude Code but manager -> sub_manager -> worker agent relations).

Demo's can be ran with the wasmind_cli

• 📚 Wasmind Book - Comprehensive user and developer guides
• ⚙️ Configuration Guide - Complete configuration reference
• 🎭 Example Actor Documentation - Individual actor guides and APIs
• 💻 CLI Documentation - Command-line interface guide

We welcome contributions to Wasmind! Whether you're building new actors, improving the core system, or have ideas for new features:

• 🐛 Found a bug? Open an issue
• 💡 Have a feature idea? Start a discussion
• 🛠️ Want to contribute code? See our Developer Guide to get started

All contributions, big and small, are appreciated!

MCP (Model Context Protocol) provides a standardized way for AI assistants to connect to external tools and data sources. It's designed for a client-server model where a single AI assistant connects to multiple tool servers.

Wasmind is fundamentally different - it's a full actor-based coordination system that enables:

• Multi-agent hierarchies: Agents can spawn and coordinate other agents, creating delegation networks (manager → sub-manager → worker patterns)
• Peer-to-peer coordination: Actors communicate directly without going through a central assistant
• Stateful actors: Each actor maintains its own state and lifecycle, enabling long-running workflows
• Massive parallelism: Thousands of actors can work concurrently on different parts of a problem
• AND MORE: ...

MCP is great for "one assistant, many tools" architectures. Wasmind enables entirely new architectures like swarms of specialized agents, hierarchical delegation networks, and massively parallel problem-solving systems that would be impossible to express in MCP's client-server model.

Bonus: MCP can actually be wrapped as a Wasmind actor!

Actors provide natural isolation, parallelism, and fault tolerance. Each actor maintains its own state and communicates only through message passing, making it easy to reason about complex systems. This model scales from simple workflows to thousands of concurrent agents without changing the programming model.

WebAssembly components give us:

• Language independence - write actors in Rust, Python, JavaScript, or any language that compiles to WASM
• Security - sandboxed execution with capability-based security
• Portability - run the same actors anywhere WASM runs
• Performance - near-native execution speed with minimal overhead
• Composability - link actors together using standard component model interfaces

Yes! The CLI (wasmind_cli) is just one example of what you can build with Wasmind. The core library (Wasmind) can be embedded in any Rust application. You can build web services, desktop apps, or any system that needs actor-based coordination.

Wasmind's actor model naturally supports thousands of concurrent actors with minimal overhead. The scope system enables hierarchical coordination, message passing is async by default, and WebAssembly provides lightweight isolation.

To use wasmind_cli and existing actors, no. To build new actors, no - actors can be written in any language that compiles to WebAssembly components but we currently only have friendly SDKs for Rust. We're working on SDKs for other languages.

Once actors are built, users create powerful AI systems purely through TOML configuration files. Want a coding assistant? Configure an assistant actor with bash and file tools. Need a review system? Add approval actors. Scale to hundreds of agents? Just update the config. No programming required - just describe what actors you want and how they connect.

MIT License - see LICENSE for details.