316K lines. 170+ MCP tools. 27 agents. Built solo in 5 weeks. Governed by Lattice Runtime.
Work in Progress — First stable release targeted for March 31, 2026. Star and watch to follow along.
Lattice Runtime is the crash-proof governed runtime for AI agents — durable execution, cryptographic audit, budget enforcement, zero-trust mesh. But a runtime alone is not useful. You need a way to create, manage, and observe agents running on it.
Workbench is that interface. It connects to Runtime over gRPC and gives you:
-
A production workspace for AI agents. Each agent (minion) gets its own git worktree, conversation history, and tool access — organized into pipeline stages.
-
Visible governance. When connected to Runtime, you see agent lifecycle events, audit trails, and budget consumption in real-time. Kill an agent from the dashboard, watch it resurrect, read the cryptographic proof.
Read the Preamble for the founding vision and philosophy.
Workbench organizes AI agents (called minions) into a software delivery pipeline. Each minion gets its own isolated execution environment, its own conversation history, and its own tool access. Organize them into stages. Let them spawn child agents for parallel work. Connect to Runtime for institutional governance — or run standalone for local development.
┌─────────────────────────────────────────────────────────────────────────────┐
│ LATTICE WORKBENCH │
│ Engineering Stack on Runtime │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Intake │ │ Build │ │ Review │ │ Deploy │ │ Monitor │ ... │
│ │──────────│ │──────────│ │──────────│ │──────────│ │──────────│ │
│ │ Triage │ │ Feature │ │ Code Rev │ │ CI/CD │ │ Alerts │ │
│ │ Classify │ │ Bug Fix │ │ Security │ │ Release │ │ Health │ │
│ │ Assign │ │ Refactor │ │ Approve │ │ Rollback │ │ Respond │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ Each minion: own git worktree · own conversation · own tools · governed │
│ │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ Inherits from Runtime: Identity · Auth · Budget · Audit · Networking │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
- Minion isolation: Each minion gets its own git worktree, runtime, and conversation history — no cross-contamination between agents
- Multi-model support: Claude, GPT, Gemini, Grok, Deepseek, Ollama, OpenRouter, Lattice Inference — any provider, swap freely
- Built-in agent types: Pre-configured exec, plan, explore, and orchestrator agents with distinct tool policies
- Sidekick spawning: Minions spawn child minions for parallel work — each with its own worktree
- Agent definitions: Markdown files with frontmatter configure agent behavior, base type, and prompts
- Plan/Exec modes: Strategic planning phase (analysis only) and execution phase (tool use)
- Stages: Pipeline stages (Intake, Build, Review, Deploy, etc.) for organizing minions visually
- Scheduling: Cron-based jobs — morning briefings, nightly builds, weekly reports
- Cost tracking: Token usage and API spend per minion, per project, per team
- MCP tools: 170+ functions for minion management, project CRUD, browser automation, and more
- Document ingestion: Analyze PDF, DOCX, XLSX, PPTX files directly in conversations
- Rich output: Mermaid diagrams, LaTeX, syntax-highlighted code, streaming markdown
| Mode | Description |
|---|---|
| Local | Direct execution in your project directory |
| Git Worktree | Isolated branch-based development — each minion on its own branch |
| SSH | Remote execution on any server |
| Docker | Container-based sandboxed execution |
| Platform | Architecture | Installer |
|---|---|---|
| macOS | Apple Silicon (arm64) | .dmg |
| macOS | Intel (x64) | .dmg |
| Windows | arm64 | .exe |
| Windows | x64 | .exe |
| Linux | arm64 | .AppImage |
| Linux | x86_64 | .AppImage |
Desktop (Electron), Web (server mode), CLI, and VS Code Extension.
Or install via Homebrew (macOS / Linux):
brew install latticehq/lattice/lattice-workbenchWorkbench works standalone — no Runtime required for local development:
- Install Lattice Workbench (download or
brew install) - Open Lattice and create a project pointing at your repo
- Create minions — each gets its own git worktree
- Organize them into stages for pipeline-style organization
- Set up scheduled jobs for recurring tasks (optional)
For institutional coordination — identity, audit, cross-team governance:
- Deploy Lattice Runtime
- Connect Workbench to your Runtime instance
- Your agents now inherit organizational identity, authorization, and audit
When connected to Runtime, every agent action passes through the four enforcement gates — Identity, Authorization, Constraints, Audit — without Workbench implementing any of it. The stack inherits governance from the coordination layer.
Lattice ships with a 10-stage software delivery pipeline in .lattice/agents/:
| Agent | Purpose |
|---|---|
intake.md |
Triage incoming issues and bug reports |
discovery.md |
Research and technical spikes |
planning.md |
Architecture decisions, task breakdown |
build.md |
Feature implementation, bug fixes |
test.md |
Test plans, regression testing |
review.md |
Code review, security checks |
docs.md |
Documentation and changelogs |
deploy.md |
CI/CD, releases |
monitor.md |
Production monitoring, alerts |
learning.md |
Retrospectives, process improvement |
Plus chief-of-staff.md (orchestrator), exec.md, and plan.md.
Agent definitions are markdown files with frontmatter. Build your own agents or customize the built-in ones:
---
name: code-reviewer
base: review
model: claude-sonnet-4-6
tools: [read, grep, glob]
---
You are a senior code reviewer. Focus on security, performance,
and maintainability. Flag any OWASP Top 10 vulnerabilities.Workbench is the Engineering Stack. It is not the only stack.
The same architecture that powers Workbench can power stacks for any department:
| Stack | Domain | Who Builds It |
|---|---|---|
| Engineering (Workbench) | CI/CD, code review, testing, deployment | @latticeHQ |
| Clinical | Patient coordination, care plans, compliance | Community |
| Legal | Contract review, compliance monitoring, drafting | Community |
| Finance | Expense tracking, forecasting, audit, reporting | Community |
| Support | Ticket triage, resolution, escalation, knowledge | Community |
Every stack inherits the same coordination primitives from Runtime — identity, authorization, budget, audit, networking. Stack developers focus entirely on domain logic.
Building a stack? See the Stack SDK guide and study this repo as the reference implementation.
| Component | Role | Repository |
|---|---|---|
| Enterprise | Enterprise administration and governance | Coming soon |
| Homebrew | One-line install on macOS and Linux | latticeHomebrew |
| Inference | Local AI serving — MLX on Apple Silicon, zero-config clustering | latticeInference |
| Operator | Self-hosted deployment management for Lattice infrastructure | latticeOperator |
| Public | Website + binary releases | lattice |
| Registry | Community ecosystem — Terraform modules, templates, stacks | latticeRegistry |
| Runtime | Crash-proof runtime — identity, auth, audit, budget, mesh | latticeRuntime |
| SDK | Go SDK for building Department Stacks | latticeSDK |
| Terraform Provider | Infrastructure as code for Lattice deployments | terraform-provider-lattice |
| Toolbox | macOS app manager for Lattice products | latticeToolbox |
| Workbench (this repo) | Reference Engineering Stack — multi-model agent workspace | You are here |
See AGENTS.md for development setup and guidelines.
Lattice Workbench is licensed under MIT.
latticeruntime.com — Crash-proof governed runtime for AI agents.