Lattice

Local-first agent runtime that runs on your own machine

Lattice is the local runtime daemon that powers the Ada CLI, Ada desktop, local agent execution, sessions, file sync, and trust mesh. Everything runs on your own hardware. Cloud access is optional and always under your control.

Lattice vs Lattice Cloud: Lattice is the runtime on your machine. Lattice Cloud is a separate product — a distributed-compute coordination layer and marketplace that routes inference across many machines. You can run Lattice without ever connecting to Lattice Cloud.

Lattice Overview

Lattice runs as a background daemon on your machine, managing agents, sessions, LLM provider connections, and local data storage. It gives you a complete local AI agent platform with maximum privacy and offline capability.

Core Components

🏠 Local Agent Runtime

• Agent Execution: Run AI agents locally with full privacy and control
• Custom Models: Integration with local LLMs via Ollama and other providers
• Development Mode: Hot-reload agent development with immediate feedback
• Resource Management: Control CPU, memory, and GPU allocation for agent workloads

🔧 MCP Development Environment

• Local MCP Servers: Host and develop Model Context Protocol servers locally
• Tool Development: Create custom tools with immediate testing capabilities
• Protocol Testing: Validate MCP compliance and integration patterns
• Debug Console: Real-time debugging of MCP server interactions

🔄 Optional Cloud Integration

• Selective Sync: Choose which data to sync with Lovelace platform services
• Fallback Strategies: Graceful degradation when cloud services are unavailable
• Authentication: Seamless authentication with platform services when desired
• Data Sovereignty: Maintain full control over sensitive data and processing

🌐 Personal Runtime For Apps

• Managed Relay: Pair your daemon with Lattice Cloud without opening an inbound port
• Local Execution: Let an app send authenticated requests while the model work still runs on your machine
• Model Selector: Route requests with model: "lattice:personal:<latticeId>"
• Setup Guide: See Personal Lattice Runtimes

Key Features

Privacy-First Development

Complete Local Execution

• No Cloud Dependencies: Develop and run agents without internet connectivity
• Data Isolation: All processing happens on your local machine
• Encrypted Storage: Local data encrypted at rest with user-controlled keys
• Network Controls: Fine-grained control over network access for security

Hybrid Deployment Options

• Local-First: Default to local execution with optional cloud integration
• Selective Cloud: Choose specific services to use from the cloud
• Air-Gapped Mode: Complete isolation for sensitive development work
• Compliance Ready: Meet enterprise security and compliance requirements

Developer Experience

Local Development Server

• Hot Reload: Instant agent and tool updates during development
• Debug Interface: Rich debugging tools for agent execution and MCP interactions
• Performance Profiling: Local profiling tools for optimization
• Development Dashboard: Visual interface for managing local services

IDE Integration

• VS Code Extension: Native integration with development environment
• Language Servers: IntelliSense and code completion for agent development
• Testing Framework: Local testing infrastructure for agents and tools
• Documentation Generation: Automatic documentation for custom tools and agents

Platform Integration

Lattice Architecture

Lattice Architecture:
┌─────────────────────────────────────────────────────────────────┐
│                  Local Interface                                │
├─────────────────┬─────────────────┬─────────────────┬───────────┤
│   CLI Commands  │  Debug Console  │  VS Code Ext    │ Dashboard │
│   • lattice   │   • Logs        │   • IntelliSense │ • Agents  │
│   • dev         │   • Profiler    │   • Debug       │ • MCP     │
│   • test        │   • Network     │   • Test        │ • Config  │
└─────────────────┴─────────────────┴─────────────────┴───────────┘
┌─────────────────────────────────────────────────────────────────┐
│                   Local Services                                │
├─────────────────┬─────────────────┬─────────────────┬───────────┤
│ Agent Runtime   │  MCP Servers    │  Local Models   │ Storage   │
│ • Execution     │ • Custom Tools  │ • Ollama        │ • Files   │
│ • Scheduling    │ • Protocol      │ • Local APIs    │ • Config  │
│ • Monitoring    │ • Discovery     │ • GPU Support   │ • Logs    │
└─────────────────┴─────────────────┴─────────────────┴───────────┘
┌─────────────────────────────────────────────────────────────────┐
│            Optional Platform Services (user-controlled)         │
├─────────────────┬─────────────────┬─────────────────┬───────────┤
│ Optional Sync   │  Authentication │  Lattice Cloud  │ Telemetry │
│ • Selective     │ • Platform Auth │ • Compute layer │ • Metrics │
│ • Encrypted     │ • Team Access   │ • Separate svc  │ • Privacy │
└─────────────────┴─────────────────┴─────────────────┴───────────┘

Getting Started

Installation & Setup

Install and Start

# macOS and Linux
curl -fsSL https://uselovelace.com/lattice/install.sh | sh

# Windows (PowerShell as Administrator)
irm https://uselovelace.com/lattice/install.ps1 | iex

# Start the daemon
lattice-ctl daemon start

# Verify it's running
lattice-ctl ping

Configure an LLM Provider

# Anthropic Claude
ada config provider set anthropic --api-key sk-...

# OpenAI
ada config provider set openai --api-key sk-...

# Local model via Ollama (free, private)
ada config provider set ollama --base-url http://localhost:11434 --model mistral

Start Working

# Interactive chat session
ada chat

# Run an autonomous agent
ada agents start "Analyze this codebase and find issues"

# View running agents
ada agents list

First Agent

1. Start an Autonomous Agent

# Start agent with a task
ada agents start "Review the authentication code and suggest improvements"

# Check status
ada agents status <agent-id>

2. Interactive Sessions

# Start a chat session
ada chat

# List saved sessions
ada sessions list

# Resume a previous session
ada sessions resume

Local Development Features

Agent Development Environment

Local Agent Execution

• Offline Capable: Run agents without internet connectivity
• Custom Models: Use local LLMs through Ollama, GPT4All, or custom APIs
• Resource Control: Configure memory, CPU, and GPU limits per agent
• Development Mode: Hot-reload agents during development

Testing & Debugging

• Local Test Suite: Comprehensive testing framework for agents
• Debug Console: Real-time debugging with breakpoints and inspection
• Performance Profiling: CPU, memory, and execution time profiling
• Network Monitoring: Track all network requests and responses

MCP Server Development

Custom Tool Development

• Tool Templates: Pre-built templates for common tool patterns
• Protocol Validation: Automatic MCP protocol compliance checking
• Local Registry: Manage and discover local MCP servers
• Integration Testing: End-to-end testing of MCP tool chains

Server Management

• Auto-Discovery: Automatic detection of local MCP servers
• Dependency Management: Handle tool dependencies and versions
• Configuration Management: Environment-specific configurations
• Health Monitoring: Real-time health checks and restart capabilities

Optional Cloud Integration

Selective Sync

• Choose Services: Select which platform services to integrate with
• Authentication Sync: Optional sync with platform authentication
• Data Sync: Selective synchronization of sessions and configurations

Privacy Controls

• Data Classification: Tag data as local-only or sync-allowed
• Network Policies: Configure which services can access the internet
• Encryption: End-to-end encryption for all platform communications
• Audit Logging: Complete logs of all external interactions

Configuration & Customization

Daemon Configuration

Resource Management

Edit ~/.lovelace/lattice/config.toml:

[daemon]
max_agents = 10
log_level = "info"

[resources]
max_memory_mb = 8192
max_cpu_percent = 50

[orchestrator]
default_provider = "ollama"

Provider Configuration via CLI

# View current config
ada config show

# Set a config value
ada config set <key> <value>

# Direct daemon config
lattice-ctl config show
lattice-ctl config edit

Storage Location

~/.lovelace/lattice/
├── config.toml         ← your settings
├── lattice.db          ← SQLite database (agents, sessions, tasks)
└── daemon.sock         ← IPC socket (temporary)

Integration Options

IDE Integration

• VS Code Extension: Native Lattice integration in VS Code
• Debug Support: Integrated debugging for agents and MCP servers
• IntelliSense: Code completion and validation for agent development
• Testing Integration: Run and debug tests directly from IDE

CI/CD Integration

• GitHub Actions: Pre-built actions for Lattice testing
• Local Runners: Use Lattice as CI/CD runner for private builds
• Docker Support: Containerized Lattice environments
• Testing Pipelines: Automated testing of agents and tools

Use Cases

For Individual Developers

• Privacy-Focused Development: Keep all development work local and private
• Offline Development: Work on agents and tools without internet connectivity
• Custom Model Integration: Use local LLMs and custom AI models
• Rapid Prototyping: Quick iteration on agent ideas without cloud setup

For Development Teams

• Shared Local Environments: Consistent development environments across team
• Security Compliance: Meet enterprise security requirements with local execution
• Custom Tool Development: Collaborate on custom MCP tools and integrations
• Hybrid Workflows: Combine local execution with optional platform services

For Enterprise Organizations

• Data Sovereignty: Maintain complete control over sensitive data and AI processing
• Air-Gapped Development: Develop AI solutions in completely isolated environments
• Compliance: Meet regulatory requirements for data handling and AI development
• Custom Infrastructure: Integrate with existing enterprise infrastructure and tools

Enterprise Features

Security & Compliance

• Air-Gapped Operation: Complete isolation from external networks when required
• Encryption: All data encrypted at rest and in transit with enterprise-grade encryption
• Access Controls: Role-based access control with enterprise identity integration
• Audit Trails: Comprehensive audit logging for all development and execution activities

Enterprise Integration

• LDAP/AD Integration: Seamless integration with enterprise identity systems
• VPN Support: Native support for enterprise VPN and proxy configurations
• Custom Models: Integration with enterprise AI models and APIs
• Monitoring Integration: Export metrics to enterprise monitoring systems

Professional Services

• Enterprise Setup: Professional setup and configuration for enterprise environments
• Custom Tool Development: Professional services for custom MCP tool development
• Training Programs: Team training on Lattice development and best practices
• Support: Dedicated enterprise support for critical development workflows

Support & Resources

Documentation

• Developer Guide - Complete local development documentation
• MCP Development - MCP server and tool development guide
• Configuration Reference - Complete configuration options
• Troubleshooting - Common issues and solutions

Community

• Lattice Forum - Local development discussions
• GitHub Repository - Open source components
• Discord #lattice - Real-time community support

Enterprise

• Enterprise Console - Enterprise management
• Professional Services - Custom development services
• Training Programs - Team training and certification

Next Steps: Install Lattice to get started with local development, or explore the Developer Guide for comprehensive development documentation.