Build with AI.
Locally. Privately. Yours.

Download & Install #

System Requirements

Installation Methods

MBS Workbench_x64-setup.exe

MBS Workbench_x64_en-US.msi

MBS Workbench.exe (134 MB)

Quick Start #

Get productive in under 5 minutes. Here's everything you need to go from install to your first AI-assisted coding session.

Code Editor #

MBS Workbench includes a full Monaco-powered code editor — the same engine that powers VS Code. You get an enterprise-grade editing experience without any external dependencies.

AI Chat & Autonomous Agent #

MBS Workbench includes a 23-tool autonomous agent powered by a structured ReAct (Reason → Act → Observe) state machine — not brittle prompt chains. Give it a task in natural language and it will plan, execute, and iterate until it's done.

Agent Capabilities

Safety System

A three-tier permission system protects you from unintended side effects:

@-Context Injection

Inject precise context into any AI conversation by typing @ followed by a context source:

Multi-File AI Edits

The AI agent can propose changes across multiple files simultaneously. You get a unified diff viewer with:

• Side-by-side diff comparison
• Accept / Reject controls per file
• Accept All / Reject All bulk actions
• File tree showing all changed files

Model Management #

Loading Models

MBS Workbench supports any GGUF-format model — the industry standard for local LLM inference. Models are loaded directly into process memory with native CUDA GPU offloading.

Recommended Models

GPU Acceleration (CUDA)

MBS Workbench embeds llama.cpp with native CUDA bindings directly in the Tauri binary. Unlike Ollama or LM Studio, there's no separate inference server — the model runs in the same process as the editor.

Model Parameters

Fine-tune inference behavior from the Parameters panel:

Cloud Providers (10 APIs)

While MBS Workbench is built for local inference, you can connect to 10 cloud LLM providers for hybrid workflows. Mix local and cloud models in the same session with real-time cost tracking.

Configure API keys in Settings → Cloud Providers. The unified provider selector in chat lets you switch between local and cloud models per-message. An OpenAI-compatible fallback supports any additional provider.

Speculative Decoding

Accelerate inference by pairing a large model with a smaller draft model. The draft model generates candidate tokens that the main model verifies in parallel — delivering 2-3x speedup on compatible hardware.

Embeddings & Vision

Load embedding models for local RAG (Retrieval-Augmented Generation) and semantic search. Vision model support (LLaVA, Qwen-VL) lets you paste images directly in chat for screenshot-to-code workflows and image analysis.

HuggingFace Explorer #

Browse and download from HuggingFace's 800,000+ model library without leaving the app. MBS Workbench scores every model against your hardware for instant compatibility assessment.

Inline AI Completions #

Get real-time AI-powered code suggestions as you type — similar to GitHub Copilot, but running entirely on your local GPU with zero latency and complete privacy.

• Ghost text appears as you type (400ms debounce)
• Press Tab to accept, Esc to dismiss
• Context-aware: reads surrounding code for accurate suggestions
• Toggle on/off from the editor toolbar
• Works with any loaded model — no separate "completion model" needed

Integrated Terminal #

A full terminal emulator built into the bottom panel — no need to switch between windows.

• xterm.js-powered terminal with PTY backend
• Auto-syncs working directory with your workspace
• Toggle with Ctrl+`
• Run commands, install dependencies, start servers
• Agent can execute commands through the terminal

MCP Servers #

MBS Workbench ships with full Model Context Protocol (MCP) infrastructure and 24 pre-configured server definitions spanning 8 domains. MCP enables your AI model to interact with external tools, APIs, and services through a standardized JSON-RPC 2.0 protocol.

Language Server Protocol (LSP) #

Built-in LSP client for professional-grade language intelligence:

• Real-time diagnostics (errors & warnings) in the editor
• Symbol extraction and navigation
• Document synchronization (open / change / save)
• Start/stop language servers from the UI
• Automatic server restart on crash

Extensions #

MBS Workbench ships with a built-in extension system:

Search & Replace #

Powerful workspace-wide search with regex, case sensitivity, include/exclude glob filters, and bulk replace. Results are grouped by file with match highlighting. Access via Ctrl+Shift+F or the Search panel in the Activity Bar.

Live Preview #

Preview HTML, CSS, and JavaScript projects in a split pane without leaving the editor. The embedded Warp HTTP server provides instant hot-reload as you type. Toggle with View → Toggle Preview.

Debug & Test #

Full DAP (Debug Adapter Protocol) integration with 9 debug adapters — Node.js, Python, Rust, Go, C/C++, Java, .NET, PHP, and Ruby. Set breakpoints, step through code, inspect variables, evaluate expressions, and view call stacks — all inside MBS Workbench.

Integrated test runner with support for npm test, cargo test, pytest, and jest. Task auto-detection discovers package.json scripts, Cargo targets, and Makefiles automatically. Test results display inline with pass/fail status.

Source Control (Git) #

Complete Git integration powered by git2-rs (native Rust bindings) and porcelain v2 commands. Full SCM sidebar with visual staging, inline blame, and merge conflict resolution.

Push, pull, and fetch operations run asynchronously with progress notifications. SCM toolbar provides one-click access to commit, stage all, unstage all, pull, push, and branch switching.

AI Refactoring #

AI-powered code refactoring with real safety checks — the refactoring engine actually runs your test suite (npm test, cargo test, pytest) before and after each transformation to verify correctness.

Multi-Model Chat #

Chat with multiple AI models simultaneously in a side-by-side view. Compare responses, run model tournaments, and track cost per query across providers.

• Simultaneous chat — send one prompt, get responses from 2-4 models at once
• Tournament mode — blind comparison where you pick the best response
• Cost analysis — real-time token cost tracking per provider (OpenAI, Anthropic, Google, local)
• Templates — save and reuse multi-model comparison setups
• Local + Cloud — mix local GGUF models with cloud APIs in the same session

Voice Input (STT) #

Live microphone speech-to-text powered by the browser's built-in Web Speech Recognition API — no external binary, no cloud. Continuous recording mode streams interim and final transcripts in real time. Use it to dictate code, chat messages, or search queries entirely on-device.

• One-click Start / Stop recording with visual indicator
• Language selection (auto-detect or manual BCP-47 code)
• Interim transcript streamed as you speak
• Full error messaging — microphone denied, no speech, audio capture failures
• No external binary required — works via WebView2 on all supported Windows versions

Image Generation #

Generate images from text prompts using Stable Diffusion running entirely on your GPU. Supports SD 1.5, SDXL, and FLUX architectures with automatic model detection and configuration. No cloud fees, no API limits — unlimited generation on your own hardware.

Model Training #

Fine-tune LoRA and QLoRA adapters on your own codebase or domain-specific data. Train specialized models that outperform generic models on your specific tasks — from 4 GB laptops to multi-GPU workstations.

• 6 use-case presets: Code Completion, Bug Fixer, Refactoring, Test Generator, Documentation, Full Agent
• Pre-flight checks validate CUDA, VRAM, disk space, and dataset before training starts
• Automatic OOM recovery — reduces batch size and enables gradient checkpointing on the fly
• Cloud GPU rental integration (one-click provisioning with cost monitoring and auto-shutoff)

Ollama-Compatible API Server #

MBS Workbench includes a built-in HTTP server with OpenAI-compatible and Ollama-compatible API endpoints. Point any tool that supports the OpenAI API format at your local MBS instance and get responses from your locally loaded model.

• /v1/chat/completions — OpenAI-compatible chat endpoint
• /api/generate — Ollama-compatible generation endpoint
• API key management for access control
• Server start/stop from the UI or command palette

Remote Development #

Develop on remote machines via real SSH connections (OpenSSH), run code inside Dev Containers (real docker build and docker run), and sync files via SCP.

Docker & Kubernetes #

Full container management without leaving your IDE. MBS Workbench integrates directly with Docker Engine and Kubernetes clusters.

Docker Dashboard

Kubernetes Explorer

Visual cluster browser with context/namespace management, pod inspection (logs, describe, YAML), service & deployment management, port-forwarding, and resource YAML apply/delete.

Compose → K8s Converter

Convert Docker Compose files into Kubernetes manifests with one click. Generates Deployments, Services, Ingress, PVCs, HPAs, and health checks. Includes a Dockerfile generator for 6 frameworks (Node, Python, Rust, Go, Java, Static).

Local Cluster Provisioning

Create and manage local Kubernetes clusters through Minikube, Kind, or k3d — directly from the UI.

Cloud GPU Hub #

Need more GPU power than your local hardware provides? The Cloud GPU Hub lets you rent cloud GPUs from leading providers — directly from within MBS Workbench.

Cloud Deployment #

Deploy to any major cloud provider with a unified interface:

Each provider includes CLI detection, login management, deployment history, logs, and config template generation.

Model Export & Conversion #

Convert models to production formats for edge deployment:

Includes device-specific optimization, size estimation, cloud storage upload (S3/GCS/Azure), and inference code generation for Python, Swift, and Kotlin.

Cost Analytics #

Track and optimize your AI spending across all providers. Five-tab dashboard covering overview, cost breakdown by provider/model, pricing reference, budget alerts with thresholds, and local-vs-cloud ROI analysis. See exactly how much you save by running locally.

Keyboard Shortcuts #

MBS Workbench uses familiar VS Code shortcuts. Here are the most important ones:

General

Activity Bar Panels

Editor

Themes & Appearance #

MBS Workbench ships with three theme modes and a built-in theme editor:

The Theme Editor lets you customize colors, radii, shadows, and spacing through a visual JSON-based editor. Over 100 CSS custom properties (design tokens) control every visual element.

Command Palette #

Press Ctrl+Shift+P to open the Command Palette — a fuzzy-search overlay that indexes all 52+ commands across 7 categories (AI & Models, Connections, Debug & Test, Deploy & Cloud, Extensions, Navigation, Editor). Type to filter, arrow keys to navigate, Enter to execute.

Settings #

All configuration is managed through the Settings panel. Inference parameters, theme preferences, keyboard shortcuts, cloud API keys, and extension state are all accessible from one place. Settings persist across sessions via local storage.

Guides #

Step-by-step tutorials to get the most out of MBS Workbench. Each guide walks through a real-world workflow from start to finish.

Your First AI Project #

Build a complete web app from scratch using the AI agent — no prior experience needed.

Agent Workflows #

The autonomous agent uses a ReAct (Reason → Act → Observe) loop. Here's how to leverage it effectively.

Prompt Engineering for the Agent

Multi-File Editing

When the agent modifies multiple files, you get a unified diff panel showing all changes. Best practices:

• Review the file tree on the left — click any file to jump to its diff
• Accept/Reject per-file or use bulk actions
• The agent tracks its own progress in a todo list visible in the UI
• If something looks wrong, type "undo that last change" in chat

Choosing the Right Model #

Different tasks call for different models. Here's a decision matrix based on your hardware and use case:

Quantization Guide

GGUF models come in various quantization levels. Here's what they mean:

GPU Optimization Guide #

Get the best inference performance from your NVIDIA GPU.

Prerequisites

• NVIDIA GPU with CUDA Compute Capability 5.0+ (GTX 900 series or newer)
• Latest NVIDIA drivers (Game Ready or Studio)
• MBS Workbench detects CUDA automatically — no toolkit installation needed

VRAM Budget Planning

Your GPU VRAM determines what models you can run and how fast. Here's how VRAM is allocated:

Performance Tuning Tips

Custom MCP Servers #

Extend MBS Workbench's capabilities by adding your own MCP servers. MCP servers expose tools to the AI model via JSON-RPC 2.0 over stdio.

Creating a Custom Server

// my-mcp-server.js — Minimal MCP server example
const { Server } = require('@modelcontextprotocol/sdk/server');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio');

const server = new Server({ name: 'my-custom-tools', version: '1.0.0' }, {
  capabilities: { tools: { listChanged: false } }
});

server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'get_weather',
    description: 'Get weather for a city',
    inputSchema: {
      type: 'object',
      properties: { city: { type: 'string', description: 'City name' } },
      required: ['city']
    }
  }]
}));

server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'get_weather') {
    const city = request.params.arguments.city;
    return { content: [{ type: 'text', text: `Weather in ${city}: 72°F, sunny` }] };
  }
});

const transport = new StdioServerTransport();
server.connect(transport);

Registering Your Server

Open MCP Manager (Ctrl+Shift+M), click Add Server, and configure:

Docker Deployment #

Deploy your project using Docker directly from MBS Workbench.

Building a RAG Pipeline #

Use Retrieval-Augmented Generation (RAG) to give your AI model access to your project's documentation, codebase, or any document corpus.

API Reference #

Complete reference for MBS Workbench's internal APIs, Tauri commands, agent tools, and configuration schemas.

Tauri Commands (IPC) #

All communication between the React frontend and Rust backend happens via Tauri's IPC bridge. Each command is invoked with invoke('command_name', { args }).

LLM & Inference

File System

Project & Workspace

Agent Tool API #

The autonomous agent has access to 23 tools organized into 7 categories. Each tool follows a strict JSON schema for input/output.

Tool Definitions

MCP Protocol #

The Model Context Protocol uses JSON-RPC 2.0 over stdio for communication between MBS and MCP servers.

Lifecycle

MBS Workbench             MCP Server
     │                         │
     │──── initialize ────────►│   Server starts, reports capabilities
     │◄─── initialized ────────│
     │                         │
     │──── tools/list ────────►│   List available tools
     │◄─── tools[] ────────────│
     │                         │
     │──── tools/call ────────►│   Execute a tool with arguments
     │◄─── result ─────────────│
     │                         │
     │──── shutdown ──────────►│   Graceful shutdown
     │◄─── ok ─────────────────│

Server Configuration Schema

{
  "name": "server-name",         // Unique identifier
  "command": "node",             // Executable to run
  "args": ["./server.js"],       // Command arguments
  "env": { "API_KEY": "..." },   // Environment variables (optional)
  "transport": "stdio",          // Transport type (stdio only currently)
  "auto_start": false,           // Start on app launch
  "health_check_interval": 30,   // Seconds between health pings
  "restart_on_crash": true,      // Auto-restart on server crash
  "max_restarts": 3              // Maximum restart attempts
}

Pre-Configured Servers (24 total)

Settings Schema #

All app settings are stored locally and accessible via Ctrl+,. Here's the complete schema:

Inference Settings

Appearance Settings

Cloud Provider Settings

Complete Keyboard Shortcuts #

Full list of all keyboard shortcuts in MBS Workbench.

General

Navigation

Activity Bar Panels

Editor

AI & Chat

CLI Reference #

MBS Workbench can be launched from the command line with optional arguments:

# Open MBS Workbench
mbs-workbench

# Open a specific folder
mbs-workbench /path/to/project

# Open a specific file
mbs-workbench /path/to/file.ts

# Start with a specific model loaded
mbs-workbench --model /path/to/model.gguf

# Start in CPU-only mode (skip GPU detection)
mbs-workbench --cpu-only

# Show version
mbs-workbench --version

Design Agent #

The Design Agent is a local AI-powered design assistant that generates complete page layouts, component designs, and brand-consistent UI from natural language prompts — all running on your GPU with no cloud dependency.

Visual Canvas #

A full drag-and-drop visual editor integrated directly into the IDE. Build pages visually with real-time preview, then export clean HTML/CSS/React code.

Brand & Tokens #

Define your brand identity once and use it everywhere. Brand tokens (colors, typography, spacing, border-radius) are injected into the Design Agent, Visual Canvas, Template Marketplace, and AI Copywriter for consistent output.

Template Marketplace #

Browse and install 15 unique, production-ready templates spanning landing pages, dashboards, portfolios, e-commerce, blogs, and more. Each template ships in 8 color variants (120 total combinations) and adapts to your brand tokens automatically.

AI Copywriter #

Generate marketing copy, product descriptions, CTAs, headlines, and page content using your local LLM. The AI Copywriter respects your brand tone and outputs clean, usable text with a 512-token generation limit for concise, focused copy.

SEO & Performance Analyzer #

Built-in SEO and performance analysis for your pages and projects. Checks meta tags, heading structure, image alt text, page speed metrics, and accessibility compliance — all locally, no third-party services.

Asset Manager #

Organize, optimize, and manage images, icons, fonts, and other assets directly in the IDE. Drag-and-drop upload, automatic image compression, SVG optimization, and sprite generation.

Voice Studio (TTS) #

A full text-to-speech studio built into the IDE. Synthesize speech locally using Kokoro-82M ONNX (22 neural voices, no internet required) or Windows SAPI as a zero-install fallback. Audio is decoded directly in the browser using a Blob URL — no external protocol configuration needed.

Mobile Export #

Export your web projects to native mobile apps with one click. MBS supports Capacitor (iOS/Android native), PWA (Progressive Web App), and APK (Android Package) export targets. Projects export to Documents/MBS-Mobile-Exports.

Interactive SDK #

Build interactive forms, surveys, quizzes, and multi-step workflows with a visual form builder. The SDK supports conditional logic, field validation, file uploads, and webhook integrations — all rendered client-side with zero backend required.

Architecture #

MBS Workbench is built on Tauri + Rust + React — a modern architecture that delivers near-native performance in a compact, self-contained native app.

Technology Stack

Performance Tuning #

Inference Optimizer (Zero Configuration)

MBS Workbench includes a built-in inference optimizer that automatically configures every loaded model for maximum speed on your hardware. No manual tuning required.

Hardware-Aware Scaling

At launch, MBS detects your exact hardware configuration and scales every subsystem:

Memory Architecture

Three-tier memory system ensures optimal performance:

Privacy & Security #

• No account required — download, install, use. Zero signup friction.
• No telemetry — we don't collect usage data, crash reports, or metrics.
• Offline-capable — once a model is downloaded, everything works without internet.
• Agent safety tiers — three-level permission system prevents unintended side effects.
• Local-only storage — settings, history, and model metadata stored in local SQLite.
• Open model ecosystem — use any GGUF model from any source. No vendor lock-in.

How MBS Compares #

Frequently Asked Questions #

Is MBS Workbench free?

The core application is free. Future Pro features (advanced agent workflows, enterprise MCP servers, priority model access) may be offered as a one-time license — never a subscription.

What models work with MBS?

Any GGUF-format language model — Qwen, DeepSeek, Llama, Mistral, Phi, Gemma, CodeLlama, and thousands more from HuggingFace. For image generation, MBS supports Stable Diffusion 1.5, SDXL, and FLUX models. Plus, 10 cloud API providers (OpenAI, Anthropic, Google, etc.) are built in for hybrid workflows.

Do I need a GPU?

No. MBS works in CPU-only mode — just slower. For the best experience, an NVIDIA GPU with 4+ GB VRAM is recommended. Even a GTX 1660 (6 GB) provides a great experience with 7B models.

Does it send my code to the cloud?

Never. When using local models, your code and prompts never leave your machine. Cloud providers (OpenAI, Anthropic, etc.) are opt-in and clearly labeled in the UI.

How does it compare to Copilot/Cursor?

Copilot and Cursor are cloud-first tools with recurring subscriptions. MBS runs locally, costs nothing per month, and gives you complete model freedom. See the full comparison table.

Can I use it offline?

Yes. Once you've downloaded a model, everything works without internet — editing, AI completions, chat, agent, image generation, model training, terminal, and all development tools.

What about Mac and Linux?

Windows is the primary platform today. Mac and Linux builds are planned — Tauri natively supports all three platforms.