Lattice Runtime
Go 1.24+Apache 2.0Shipping

Don't adopt
a vendor.

Model-agnostic managed agent infrastructure. The brain, the hands, and the session — decoupled from any single provider.

Crash-proof governed runtime. Single Go binary. Embedded Temporal, cryptographic audit, five governance gates, six runtime backends.

Star on GitHub View Architecture
lattice-runtime — system overview

Clients

Workbench

Electron

CLI

120+ cmds

Go SDK

agentsdk

Operator

Laravel

REST / DRPC / WS

latticed (single binary)

Temporal v1.30
Identity Engine
Policy Engine
Budget Engine
Agent Lifecycle
Crypto Keys
PubSub Events
Coordinator

Temporal Workers

AgentWorkflowCoordWorkflowTaskQueue

Data

PostgreSQL

50+ tables

Audit Ledger

SHA-256

Agent State

Temporal

Governance

RBAC
ABAC
Rego→SQL
PII Filter

AI Providers (External)

Anthropic

Claude

OpenAI

GPT

Google

Gemini

Ollama

Local

Full interactive architecture → View details

The problem

The vendor is the new pet.

When your managed agent infrastructure is locked to one provider, your entire system becomes a pet tethered to one API, one pricing model, one uptime SLA.

Vendor-locked

VENDOR CLOUD

Brain

Claude only

Session

Their servers

Sandbox

Their container

Model deprecation breaks agents

Data must leave your infra

Pay Opus prices for commodity work

Provider outage = total system down

Lattice Runtime

Brain

Any model

Session

Your infra

Hands

6 backends

generate() · execute() · getEvents()

Each component is an interface. Swap without breaking.

Swap models at config, not code

Data never leaves your infrastructure

Right model for each agent role

Provider outage = automatic fallback

The fix

Decouple the brain from the model.

Three interfaces. Each can fail independently. Each can be swapped without disturbing the others.

The Brain

Model-agnostic harness. Builds context from the session, calls generate(), routes tool calls.

generate(messages, tools) → response
ClaudeGPTGeminiOllama

The Session

Durable append-only log. Lives wherever you run it. Survives crashes and model swaps.

getEvents(from, limit) → stream
PostgreSQLSHA-256 auditPortable

The Hands

Six runtime backends. Any tool, any sandbox. Brains can pass hands to one another.

execute(name, input) → string
LocalDockerSSHK8sDevcontainer

Built-in governance

Five gates. Zero trust.

Every agent action passes through five governance gates. Policy violations are structurally impossible.

Every agent action passes through

Identity

OAuth2 / SAML / mTLS

Authorization

RBAC + ABAC / Rego

Constraints

Budget / PII / Model lock

Execute

Temporal durable workflow

Audit

SHA-256 hash chain

Policy violations are structurally impossible. The infrastructure will not execute actions that fail any gate.

Crash → automatic recovery

Process crashes

Kill / OOM / provider outage

Temporal replays

Deterministic from checkpoint

Model swapped

Resume with a different model

Audit logged

SHA-256 chain, tamper-evident

Durable sessions

The session is not the context window.

The session is durable. The context window is constructed from it on each turn. Compaction is reversible. The originals never leave the log.

Session Log

DURABLE
001User message
002Tool call: git diff
003Tool result
004Model response (Opus)
005Compaction boundary
006Model response (Sonnet)
...Append-only. Portable. Yours.

Context Window

CONSTRUCTED

Build

Read from session log on each turn

Transform

Different models, different strategies

Compact

Summarize. Originals stay in log.

Recover

Rewind, slice, or replay any event

getEvents(fromCheckpoint, withLimit)

Scale

Many brains. Many hands.

An orchestrator running Opus delegates to workers running Sonnet. A review agent uses GPT for a second opinion. A sensitive-data agent uses Ollama so nothing leaves the machine.

Many Brains

Right model for each role

OrchestratorOpus

Planning, reasoning, delegation

Code WorkerSonnet

Execution, file edits, tests

Review AgentGPT-4o

Second opinion, code review

Sensitive DataOllama

Never leaves the machine

Many Hands

Six runtime backends

Local

Direct filesystem

Worktree

Git isolation

SSH

Remote servers

Docker

Container sandbox

Devcontainer

VS Code compat

Lattice SSH

Managed tunnel

execute(name, input) → string

Same interface. Any brain can pass hands to another.

Comparison

Vendor-locked vs. vendor-free

Vendor-locked

Lattice Runtime

Model

One provider only

Model

Any model, any provider

Hosting

Provider cloud

Hosting

Your cloud, your machine, or ours

Data

Provider servers

Data

Wherever you run it

Multi-agent

Single-model only

Multi-agent

Mix models per agent role

Governance

Not built-in

Governance

5 gates, budgets, crypto audit

Runtimes

Cloud container

Runtimes

6 backends (local → K8s)

Crash recovery

Provider-dependent

Crash recovery

Resume with any model

Session

Provider-managed

Session

Durable, portable, yours

Credentials

Shared environment

Credentials

Forwarded, never exposed

Audit trail

Basic logging

Audit trail

SHA-256 hash chain, tamper-evident

Provisioning

Upfront container

Provisioning

Lazy, on first tool call

273

Tests passing

424

DB migrations

6

Runtime backends

5

Governance gates

Engineering Blog

Scaling Managed Agents: Decoupling the Brain from the Model

The full technical story. Architecture diagrams, comparison tables, and code.

Run agents on your terms.

We're a two-person team rolling out access in phases. Star the repo to get on our radar — we reach out to stargazers first.

Star on GitHublattice-runtime/lattice-runtime

Star the repo · Open an issue with your use case · Watch for the invite

View Architecture Read the Blog