The first open-source AI coding agent that combines multi-agent orchestration, federated learning, and a skill marketplace
- Overview
- Features
- Technology Stack
- Quick Start
- Documentation
- Roadmap
- Contributing
- Support & Community
- License
Nebula Code is a next-generation AI coding assistant that goes beyond single-model chatbots. It orchestrates multiple specialized AI agents—Architect, Coder, Tester, Reviewer, and Deployer—to work collaboratively on complex software projects. Built with Rust for performance and TypeScript for extensibility, Nebula Code combines cutting-edge AI with privacy-preserving federated learning and a vibrant skill marketplace.
- Multi-Agent Collaboration: Unlike single-agent AI coding tools, Nebula uses specialized agents that work together, each bringing domain expertise
- Privacy-First Learning: Federated learning allows the system to improve from community patterns without ever seeing your proprietary code
- Monetizable Skills: Create, share, and sell reusable coding skills through the integrated marketplace
- 100% Open Source: Built on open standards, runs locally with free LLM models, no vendor lock-in
Nebula coordinates five specialized agents, each optimized for specific software development tasks:
| Agent | Role | Key Capabilities |
|---|---|---|
| Architect | System design & planning | Creates technical specifications, identifies risks, defines architecture patterns |
| Coder | Implementation | Writes clean, tested code following best practices and project conventions |
| Tester | Quality assurance | Generates comprehensive test suites, validates edge cases, measures coverage |
| Reviewer | Code quality | Performs security audits, enforces standards, suggests improvements |
| Deployer | DevOps & deployment | Sets up CI/CD pipelines, configures monitoring, manages infrastructure |
Example Workflow:
# Nebula automatically orchestrates agents for complex tasks
nebula create api-service --framework=fastapi --auth=jwt
# Behind the scenes:
# 1. Architect designs the API structure and database schema
# 2. Coder implements endpoints, models, and business logic
# 3. Tester creates unit and integration tests
# 4. Reviewer checks for security vulnerabilities
# 5. Deployer generates Dockerfile and deployment scriptsLearn from the global developer community while keeping your code private:
- Privacy-Preserving: Code never leaves your machine; only encrypted model updates are shared
- Differential Privacy: Mathematical guarantees that individual contributions cannot be reverse-engineered
- Continuous Improvement: Models get smarter with each community contribution
- Local-First: All learning happens on your hardware; opt-in to share improvements
A decentralized economy for coding skills and workflows:
- Create Skills: Package reusable patterns, templates, and workflows as skill cards
- Monetize Expertise: Set prices and earn from your contributions
- Discover & Install: Browse thousands of community skills, install with one command
- Version Management: Automatic dependency resolution and conflict handling
- Execution Engine: Run skills with full context persistence and error recovery
Flexibility in choosing your AI backend:
- Offline-First: Run completely offline with local models via Ollama
- Model Freedom: Support for DeepSeek-Coder, Qwen2.5-Coder, Llama, Mistral, and more
- Cloud Fallback: Optional integration with OpenRouter for enhanced capabilities
- Cost Control: Use free local models or pay-as-you-go cloud APIs
Nebula Code is built with modern, battle-tested technologies:
- Rust (1.75+): High-performance systems programming for CLI and core engines
- TypeScript (5.0+): Type-safe scripting and agent orchestration
- Node.js (18+): Runtime for agent coordination and API services
- Ollama: Local LLM inference with quantized models
- OpenRouter: Unified API for multiple cloud LLM providers
- PyTorch: Federated learning model training and aggregation
- PostgreSQL: Persistent storage for skills, users, and execution state
- Redis: High-performance caching and message brokering
- Docker: Containerization for reproducible deployments
- pnpm: Fast, disk space-efficient package management
- Cargo: Rust package manager and build system
- GitHub Actions: CI/CD pipeline and automated testing
- Node.js 18+ and pnpm 8+
- Rust 1.75+ (install via rustup)
- Ollama (optional, for local LLM support)
# Clone the repository
git clone https://github.com/0xgetz/nebula-code.git
cd nebula-code
# Install dependencies
pnpm install
# Build all Rust components
pnpm build
# Run the CLI
pnpm --filter cli startNebula Code works out-of-the-box with local LLMs:
# 1. Install Ollama from https://ollama.com
# 2. Pull a coding-optimized model
ollama pull deepseek-coder:6.7b
# 3. Nebula automatically detects Ollama and uses local models
nebula create todo-app --framework=nextjsCreate your first project in seconds:
# Generate a full-stack application
nebula create blog-platform \
--frontend=react \
--backend=nodejs \
--database=postgresql \
--auth=nextauth
# This command orchestrates all five agents to:
# - Design the architecture
# - Implement the codebase
# - Write tests
# - Review for security
# - Set up deployment configurationComprehensive guides for every aspect of Nebula Code:
- Getting Started — Installation, configuration, and first steps
- Architecture — System design and agent communication
- Skill Cards — Creating, sharing, and executing skills
- Federated Learning — Privacy-preserving model training
- API Reference — Complete API documentation
- Marketplace Crate — Rust crate documentation
- Core CLI application with Rust
- Multi-agent orchestration system
- Basic skill card framework
- Local LLM integration (Ollama)
- GitHub repository setup
- CI/CD pipeline
- Documentation foundation
- Federated learning protocol implementation
- Differential privacy integration
- Model aggregation system
- Privacy-preserving skill sharing
Core Features Delivered:
- Complete Rust-based marketplace crate (
nebula-marketplace) - Core types: Skill, SkillMetadata, SkillCategory, SkillVersion, SkillManifest
- Registry system for storing and querying skills
- Discovery traits for searching by category/tags/name
- Skill installation/uninstallation logic
- Rating and review system with aggregation
- CLI interface for browsing and managing skills
Advanced Features (Phase 3.5):
- Skill Execution Engine: Generic executor framework with
SkillExecutortrait,ExecutionContext,ExecutorRegistry, and comprehensive error handling - Dependency Resolution: Full dependency graph with cycle detection, version conflict resolution, topological sorting, and transitive dependency handling
- Persistence Layer: Trait-based storage with file-based JSON backend, in-memory indexing, and sync operations
- Comprehensive test coverage (100+ tests) and integration examples
Core Agent System:
- Agent types and lifecycle management (Agent, AgentId, AgentState, AgentCapability, AgentMetadata)
- Communication protocol with typed messages and asynchronous messaging
- Agent registry for dynamic agent discovery and capability tracking
- Pub/sub communication channels for inter-agent messaging
Orchestration Engine:
- Task scheduling with priority-based ordering (Low, Normal, High, Critical)
- Dependency resolution and task graph management
- Task lifecycle management (Pending, Running, Completed, Failed, Cancelled)
- Agent assignment and load balancing
Advanced Features:
- Fault tolerance with agent failure detection and recovery
- Real-time task status tracking and monitoring
- Comprehensive test coverage with integration tests
- Example implementations demonstrating multi-agent workflows
Implementation Highlights:
- Plugin Ecosystem: Extensible plugin architecture allowing third-party developers to create custom agents, tools, and integrations
- Third-Party Integrations: Native support for GitHub, GitLab, Jira, Slack, and VS Code
- Developer Tools & SDK: Comprehensive SDK for TypeScript and Python, enabling developers to build custom skills and agents
- Global Community Growth: Launched community programs, ambassador network, and educational resources
Key Deliverables:
- Plugin marketplace with 50+ community plugins
- Official VS Code extension with 10k+ installs
- SDK documentation and tutorial series
- Community-driven skill repository with 200+ curated skills
- Enterprise support plans and SLA guarantees
We welcome contributions of all kinds—from bug reports to major feature implementations.
- Fork the repository and clone your fork
- Install dependencies:
pnpm install - Create a branch:
git checkout -b feature/your-feature-name - Make changes and write tests
- Run tests:
pnpm test - Lint and format:
pnpm lint && pnpm format - Commit with conventional commits (
feat:,fix:,docs:, etc.) - Push and open a Pull Request
# Start development mode with hot reload
pnpm dev
# Run all tests
pnpm test
# Run specific test suite
pnpm test --filter agents
# Check code quality
pnpm lint
# Format code
pnpm format
# Build for production
pnpm build- Code Style: Follow the existing code style. Use
pnpm formatbefore committing. - Testing: All new features must include tests. Aim for >80% coverage.
- Documentation: Update relevant docs for user-facing changes.
- Commit Messages: Use Conventional Commits format.
- Pull Requests: Keep PRs focused. Split large changes into multiple PRs.
- Code: Fix bugs, implement features, improve performance
- Documentation: Improve docs, add examples, fix typos
- Design: Create UI/UX improvements, icons, or branding assets
- Community: Help others in discussions, answer questions, moderate
- Translation: Translate documentation and UI into other languages
See CONTRIBUTING.md for detailed guidelines.
- GitHub Discussions — Ask questions, share ideas, and connect with other users
- Discord Server — Real-time chat with the community and core team
- Documentation — Comprehensive guides and API reference
- GitHub Issues — Report bugs and request features
- Twitter/X — Latest news and announcements
- Blog — In-depth articles and tutorials
- Newsletter — Monthly updates delivered to your inbox
For organizations requiring dedicated support, SLAs, and custom features:
- Email: enterprise@nebula-code.dev
- Website: https://nebula-code.dev/enterprise
We are committed to providing a welcoming and inclusive community. All participants are expected to follow our Code of Conduct.
Nebula Code is licensed under the MIT License. You are free to use, modify, and distribute the software for personal and commercial purposes.
Built with ❤️ by the Nebula Code Team