GitHub - NoctuaCoder/ArbiterAI: 🐳 The Docker for AI Code Agents - Run autonomous AI agents locally with enterprise-grade Docker isolation. Zero API costs, 100% open source.

The ONLY platform combining real code execution, Docker isolation, plugin extensibility, and Git integration. 100% local, zero API costs.

🚀 Quick Start | 💰 Why ArbiterAI | ⚡ What Makes Us Unique | 🎯 Use Cases | 🔌 Plugin System

⚠️ ORIGINAL PROJECT NOTICE

ArbiterAI is an original work by NoctuaCoder
First Published: November 27, 2025
Original Repository: https://github.com/NoctuaCoder/ArbiterAI
Project ID: ARBITER-2025-NOCTUACODER-PLATFORM

This project is protected under MIT License with attribution requirements.
Any use, modification, or distribution must credit the original author.
See NOTICE file for full copyright information.

💰 Why ArbiterAI? Save Thousands!

💸 Cost Comparison - Why Pay When You Can Own?

Platform	Monthly Cost	Annual Cost	You Pay
Cursor	$20/month	$240/year	💸 💸
GitHub Copilot	$10/month	$120/year	💸
Devin	$500/month	$6,000/year	💸 💸 💸 💸 💸 💸
ArbiterAI	$0/month	$0/year	✅ FREE

🎯 Save $120-$6,000/year while keeping your code 100% private and local!

⚡ What Makes Us Unique

ArbiterAI is the ONLY platform that combines ALL of these:

Feature	GitHub Copilot	Cursor	Devin	ArbiterAI
Code Suggestions	✅	✅	✅	✅
Real Execution	❌	❌	✅	✅
Docker Isolation	❌	❌	❌	✅
Plugin System	❌	❌	❌	✅
100% Local	❌	❌	❌	✅
Git Integration	⚠️	⚠️	⚠️	✅
Zero API Cost	❌	❌	❌	✅
Open Source	❌	❌	❌	✅

Tagline: "The Docker for AI Code Agents"

🎯 Key Features

🐳 Docker Sandbox (Enterprise Security)

Container Isolation: Every command runs in ephemeral Docker containers
Resource Limits: CPU (1 core), Memory (512MB) enforced
Non-Root Execution: UID 1000 for security
Network Isolation: Disabled by default
Auto-Cleanup: Containers removed after execution

🔌 Plugin System (Unlimited Extensibility)

Auto-Discovery: Plugins loaded from plugins/ directory
Dynamic Loading: No core modifications needed
Permission System: Filesystem, network, database, cloud, shell
Community-Ready: Easy plugin development

🔄 Git Integration (Team Member Capabilities)

Local Operations: init, status, add, commit, log, diff, branch, checkout
Remote Operations: clone, push, pull, fetch, remote management
State Tracking: Comprehensive repository awareness
Workflow Automation: Complete Git workflow support

💾 Built-in Plugins

Shell Plugin: Secure command execution (Docker-based)
Database Plugin: SQLite operations with SQL injection prevention
Git Plugin: Full version control integration

🚀 Quick Start

Prerequisites

# 1. Install Docker
curl -fsSL https://get.docker.com | sh

# 2. Install Ollama (local LLM)
curl -fsSL https://ollama.com/install.sh | sh

# 3. Pull DeepSeek Coder model
ollama pull deepseek-coder

# 4. Start Ollama
ollama serve

Installation

# Clone repository
git clone https://github.com/NoctuaCoder/ArbiterAI.git
cd ArbiterAI

# Build Docker sandbox image
cd backend
chmod +x build_sandbox.sh
./build_sandbox.sh

# Install Python dependencies
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

# Start backend
python websocket_server_v2.py

Frontend (Optional)

# In new terminal
cd frontend
npm install
npm run dev

Access at http://localhost:5173 🎉

💡 Example Usage

Simple Task

User: "Create a Python hello world script"

Agent:
✅ Initialized workspace
✅ Created hello.py
✅ Executed script successfully
✅ Output: Hello, World!

Git Workflow

User: "Clone repo, create feature branch, make changes, commit, and push"

Agent:
✅ Cloned repository
✅ Created branch: feature/new-feature
✅ Made changes to code
✅ Staged files
✅ Committed: "feat: implement new feature"
✅ Pushed to origin/feature/new-feature

Database Operations

User: "Create users table and insert sample data"

Agent:
✅ Created database.db
✅ Executed: CREATE TABLE users (id, name, email)
✅ Inserted 3 sample users
✅ Query result:
   id | name  | email
   1  | Alice | alice@example.com
   2  | Bob   | bob@example.com
   3  | Carol | carol@example.com

🎯 Use Cases

🔧 DevOps & Infrastructure

User: "Set up a complete CI/CD pipeline with GitHub Actions"

Agent:
✅ Created .github/workflows/ci.yml
✅ Configured Docker build and push
✅ Added automated testing
✅ Set up deployment to production
✅ Committed and pushed to repository

Perfect for: Infrastructure automation, deployment scripts, container orchestration

📊 Data Science & Analytics

User: "Analyze this CSV dataset and create visualizations"

Agent:
✅ Loaded data with pandas
✅ Performed exploratory data analysis
✅ Created 5 visualization plots
✅ Generated statistical summary
✅ Saved results to analysis/ directory

Perfect for: Data exploration, ML model training, automated reporting

🌐 Web Development

User: "Scaffold a React + FastAPI project with authentication"

Agent:
✅ Created React frontend with Vite
✅ Set up FastAPI backend
✅ Implemented JWT authentication
✅ Added user registration/login
✅ Configured CORS and middleware
✅ Created Docker Compose setup

Perfect for: Full-stack development, API creation, rapid prototyping

🌟 As Seen On

"ArbiterAI combines Docker isolation with AI code agents for enterprise-grade security" - Perplexity AI

🏗️ Architecture

┌─────────────────┐      WebSocket      ┌──────────────────┐
│  React Frontend │ ◄─────────────────► │  FastAPI Backend │
│   (Port 5173)   │   Real-time Stream  │   (Port 8000)    │
└─────────────────┘                      └──────────────────┘
                                                  │
                                                  ▼
                                         ┌──────────────────┐
                                         │ AutonomousAgent  │
                                         │  - Planning      │
                                         │  - Tool Selection│
                                         │  - Reflection    │
                                         └──────────────────┘
                                                  │
                                                  ▼
                                         ┌──────────────────┐
                                         │    Toolbox       │
                                         │  + PluginManager │
                                         └──────────────────┘
                                                  │
                                    ┌─────────────┼─────────────┐
                                    ▼             ▼             ▼
                              ┌──────────┐  ┌──────────┐  ┌──────────┐
                              │  Shell   │  │    Git   │  │ Database │
                              │  Plugin  │  │  Plugin  │  │  Plugin  │
                              └──────────┘  └──────────┘  └──────────┘
                                    │             │             │
                                    └─────────────┴─────────────┘
                                              ▼
                                    ┌──────────────────┐
                                    │  Docker Sandbox  │
                                    │  (Isolated Exec) │
                                    └──────────────────┘

🔌 Plugin System

Creating a Plugin

# plugins/my_plugin.py

from plugin_interface import ArbiterPlugin, PluginMetadata, PluginResult

class MyPlugin(ArbiterPlugin):
    @property
    def metadata(self):
        return PluginMetadata(
            name="my_plugin",
            version="1.0.0",
            author="Your Name",
            description="What your plugin does"
        )
    
    def execute(self, **kwargs):
        # Your logic here
        return PluginResult(
            success=True,
            output="Result"
        )
    
    def describe(self):
        return {
            "name": "my_plugin",
            "description": "Detailed description for LLM",
            "parameters": {"param1": "description"},
            "examples": ["Example usage"]
        }

That's it! Plugin is auto-discovered on next startup.

Available Plugins

Shell Plugin: Execute commands in Docker containers
Database Plugin: SQLite operations
Git Plugin: Version control operations

Community Plugins (Coming Soon)

Cloud Plugin (AWS S3, GCP, Azure)
Testing Plugin (pytest, jest)
CI/CD Plugin (GitHub Actions, GitLab CI)
Monitoring Plugin (Prometheus, Grafana)

🔒 Security

Docker Sandbox

Isolation: Complete process/network/filesystem isolation
Resource Limits: Prevents DoS attacks
Non-Root: UID 1000 execution
Ephemeral: Containers destroyed after use
Network: Disabled by default

Command Validation

Whitelist: Only allowed commands execute
Blacklist: Dangerous patterns blocked
Timeout: 30s max per command
Workspace: Path traversal prevented

Plugin Security

Permission System: Plugins declare required permissions
Input Validation: All inputs validated
Sandboxing: Plugins run in isolated environment

📊 Code Statistics

Component	Lines of Code	Status
Docker Sandbox	350	✅ Production
Plugin System	550	✅ Production
Database Plugin	280	✅ Production
Shell Plugin	215	✅ Production
Git Plugin	800	✅ Production
Total	~2,200	✅ Ready

🗺️ Roadmap

✅ Completed (v4.0)

Docker Sandbox (Enterprise security)
Plugin System (Unlimited extensibility)
Git Integration (Team member capabilities)
Database Plugin (SQLite operations)
Shell Plugin (Secure execution)

🎯 Next (v4.1)

UX/Frontend Enhancement (file visualization, execution history)
Plugin Documentation (developer guide, templates)
Performance Optimization (caching, lazy loading)
GitHub API Integration (PRs, issues)

🚀 Future (v5.0)

Multi-Agent Orchestration
Plugin Marketplace
Enterprise Features (SSO, RBAC)
Cloud Deployment Options

💰 Pricing (Planned)

Free Tier (Open Source)

✅ Core platform
✅ Basic plugins
✅ Community support
✅ Self-hosted

Pro Tier ($49/month)

✅ Advanced plugins (Cloud, Testing, CI/CD)
✅ Priority support
✅ Plugin marketplace access
✅ Multi-agent orchestration

Enterprise ($499/month)

✅ On-premise deployment
✅ Custom plugin development
✅ SLA 99.9%
✅ Dedicated support
✅ Team collaboration
✅ SSO/SAML integration

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Areas of Focus

Plugin development
Frontend improvements
Documentation
Testing
Performance optimization

📄 License

MIT License - See LICENSE file for details.

Attribution Required: Any use must credit NoctuaCoder and link to the original repository.

🙏 Credits

Ollama - Local LLM infrastructure
DeepSeek Coder - Specialized code model
Docker - Container platform
FastAPI - Modern web framework
React - UI library

📞 Contact & Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Email: Contact through GitHub profile

Built with 🦉 by NoctuaCoder

ArbiterAI v4.0 - Where Security Meets Extensibility

⭐ Star this repo if you believe in secure, extensible AI agents!

Report Bug • Request Feature • Discussions

Project ID: ARBITER-2025-NOCTUACODER-PLATFORM

Name		Name	Last commit message	Last commit date
Latest commit History 18 Commits
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
backend		backend
electron-app		electron-app
frontend		frontend
.gitignore		.gitignore
ACHIEVEMENTS.md		ACHIEVEMENTS.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
DOCKER_SANDBOX.md		DOCKER_SANDBOX.md
GITHUB_SETUP.md		GITHUB_SETUP.md
LAUNCH_CHECKLIST.md		LAUNCH_CHECKLIST.md
LICENSE		LICENSE
NOTICE		NOTICE
README.md		README.md
README_V2.md		README_V2.md
docker-compose.yml		docker-compose.yml
header-arbiter.svg		header-arbiter.svg

License

NoctuaCoder/ArbiterAI

Folders and files

Latest commit

History

Repository files navigation