Lattice

Lattice is an open source native macOS project to control coding agents, unifying project context, models, tools, and conversations with transparent permissions and cloud/local control.

Comment

Inspiration

AI coding work is powerful, but the daily experience is fragmented across terminal sessions, provider-specific apps, local runtimes, and incompatible permission systems. Context gets lost, execution becomes opaque, and developers are often asked to trade control for convenience. I built Lattice to make serious agent-assisted development feel like one dependable, inspectable workspace on the Mac.

What it does

Lattice is a native macOS control plane for AI coding agents. It brings durable project conversations, structured coding harnesses, local models, provider-owned CLIs, permissions, privacy controls, and action history into one SwiftUI app.

Every new conversation starts with an explicit route:

  • Code for building, debugging, and shipping with coding harnesses.
  • Work for research, browsing, and tool-assisted tasks.
  • Local for private execution with Apple Intelligence or Ollama models available on the Mac.

Lattice discovers providers and models at runtime instead of pretending unavailable integrations work. It never silently switches modes, providers, runtimes, or models. Local-only sessions fail closed for cloud-classified routes.

The current product includes durable chats with drafts, queues, continuation, branching, editing, pinning, deletion, and search; project-bound working directories; live run and attention state; connection and model management; import/export with sensitive runtime state removed; recovery for corrupt or unwritable data; typed multimodal input; Git-native Code checkpoints; review notes; and guarded, previewed revert flows.

Its safety UI stays deliberately specific. Approvals depend on what each harness protocol can actually forward. Sandboxing is described as write containment—not a promise to prevent reads, network access, prompt injection, or exfiltration. Credentials owned by Lattice live in macOS Keychain, while provider CLIs retain their own authentication stores.

How I built it

Lattice is an open-source Swift 6 project with a native SwiftUI application and a separate LatticeCore module for testable domain policy, persistence, routing, harness behavior, and safety decisions.

Provider integrations sit behind harness boundaries and favor structured protocols over terminal scraping. Code routes include a Lattice-owned Pi-based agent path for Codex and OpenCode, plus provider-owned integrations such as Grok Build ACP. Work routes use an isolated Hermes ACP profile with curated toolsets. Local routes use Apple Foundation Models where supported and Ollama's local HTTP/NDJSON APIs.

Persistence uses atomic writes and explicit recovery states. Portable archives strip provider session IDs, live approvals, attachment bytes, and hidden reasoning. Concurrency and process ownership are bounded so stale teardown cannot cancel a replacement run, and model discovery is generation-gated so older refreshes cannot overwrite newer truth.

OpenAI Codex with GPT-5.6 was a core development partner during Build Week. I used it for codebase analysis, implementation, adversarial review, debugging race conditions, accessibility audits, and verification. The important product and safety decisions remained human-owned, and each meaningful contribution is recorded in dated commits and the repository's Build Week evidence log.

Challenges I ran into

The hardest problem was not creating just another chat UI. It was reconciling providers that expose very different capabilities without flattening those differences into misleading promises. Some routes provide structured permission events, resumable sessions, or tool activity; others do not. Lattice therefore models availability and enforceable capabilities explicitly and surfaces actionable unavailable states.

Durability was another major challenge. Agent runs stream, fail, request approval, recover, and get replaced asynchronously. Making those transitions survive relaunches without stale state clobbering a new run required careful actor isolation, bounded subprocess behavior, atomic stores, failure-path tests, and visible recovery gates.

Finally, security language had to match implementation reality. It was tempting to say “sandboxed” or “private” broadly. Instead, Lattice distinguishes cloud routing, write containment, credential ownership, broker mediation, and provider-controlled tools so developers can make informed choices.

Accomplishments that I'm proud of

  • A real native Mac workspace that keeps agent conversations and execution evidence together.
  • Runtime-discovered models with truthful loading, failed, unavailable, and recovery states.
  • Explicit Code, Work, and Local routes with no silent cross-mode fallback.
  • Durable checkpoints, scoped review notes, and conflict-aware reverts without destructive Git shortcuts.
  • Failure-focused verification covering persistence, routing, approvals, stale sessions, cancellation races, local-only enforcement, and provider process limits.
  • Accessible interaction details including keyboard behavior, VoiceOver state, and reduced-motion handling.

What I learned

A trustworthy agent product is defined as much by what it refuses to claim as by what it can execute. Structured protocols, observable state, narrow capability descriptions, and recoverable persistence matter more than flashy autonomy. GPT-5.6 was especially valuable when used as a rigorous engineering collaborator: exploring cross-cutting code, generating bounded implementations, and independently reviewing assumptions—while deterministic tests and human judgment remained the acceptance gate.

What's next for Lattice

The next flagship step is an "Inspectable Agent Mission": a project-scoped goal with an editable typed plan, user-approved parallel child runs, declared write scopes, structured status, independent review, and a final evidence bundle. Near-term work also includes deeper harness integrations, richer extension APIs, improved onboarding and accessibility, broader replay fixtures, and a signed and notarized distribution path.

Lattice is early open-source software, but the foundation is real and runnable today. The goal is simple: give developers the power of agentic coding tools without asking them to surrender visibility, continuity, or control.

Built With

  • accessibility
  • codex
  • gpt-5.6
  • keychain
  • macos
  • ollama
  • openai
  • swift
  • swift-package-manager
  • swiftui
Share this project:

Updates