Lattice

What the company appears to be: Lattice is a self-reported open-source native macOS project that presents itself as a control plane for AI coding agents. The author describes it as a SwiftUI-based application aiming to unify fragmented AI development workflows into one inspectable workspace on the Mac.

What changed: This is a single-person, early-stage open-source project submitted to an AI hackathon. No prior version or product history is evidenced. It is not demonstrated to have any revenue, users, or commercial traction.

The single most important open question: Is there evidence that Lattice has achieved meaningful developer adoption or usage beyond the author’s own development and testing?

Analysis basis: The entire report is based on a self-reported project description from the author, submitted to the OpenAI 2026 hackathon. No external verification, revenue data, customer list, or traction metrics are available.

• The description states that Lattice is a native macOS control plane for AI coding agents.
• It is built in Swift 6 with SwiftUI, and includes a separate LatticeCore module for domain logic.
• It supports three distinct routes:
  • Code: for building, debugging, shipping with coding harnesses.
  • Work: for research, browsing, tool-assisted tasks.
  • Local: for private execution using Apple Intelligence or Ollama models.
• The product includes features such as:
  • 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.
  • Guarded, previewed revert flows.

Inference: The product is described as a macOS application that integrates local and cloud-based AI tools through structured protocols. It is not a SaaS offering or a hosted service but rather an open-source tool for developers to run locally.

• The author positions Lattice as:
  • A native macOS workspace for agent-assisted development.
  • A solution to the fragmentation of AI coding workflows across terminals, apps, and incompatible permission systems.
  • A way to maintain control, continuity, and visibility in AI-assisted coding.
• It is described as a “one dependable, inspectable workspace” on the Mac.
• The author emphasizes:
  • Transparency in permissions and execution.
  • Cloud/local control.
  • No silent fallbacks or mode switching.
  • Explicit availability states for models and integrations.

Claim vs. Fact: These are self-reported claims about the product’s purpose, design philosophy, and user experience. No evidence of actual usage or customer feedback is provided.

• The target customer appears to be developers working on macOS, particularly those using AI coding tools.
• The author states that Lattice aims to make “serious agent-assisted development feel like one dependable, inspectable workspace.”
• It is positioned for developers who:
  • Want control over their AI workflows.
  • Value privacy and local execution options.
  • Are frustrated by fragmented or opaque AI tooling.

Inference: The ICP is likely early-stage developers or teams using macOS and looking to integrate AI coding agents into their workflow. No evidence of actual customer segments, personas, or usage data.

• Lattice is described as an open-source project.
• There is no mention of any pricing model, monetization strategy, or commercial offering.
• The author states that the goal is to give developers “the power of agentic coding tools without asking them to surrender visibility, continuity, or control.”
• No revenue streams, subscriptions, or licensing information are provided.

Not evidenced: No business model or pricing data is available in the description.

• Built with:
  • Swift 6
  • SwiftUI
  • macOS native
  • OpenAI Codex (GPT-5.6)
  • Ollama
  • Keychain
  • Accessibility features (VoiceOver, keyboard behavior, reduced motion)
• The architecture includes:
  • A separate LatticeCore module for domain logic.
  • Harness boundaries to isolate provider integrations.
  • Structured protocols over terminal scraping.
  • Atomic writes, explicit recovery states, and bounded subprocess behavior.
  • Concurrency control and process ownership bounds.
• The author used GPT-5.6 for:
  • Codebase analysis
  • Implementation
  • Debugging race conditions
  • Accessibility audits
  • Verification

Inference: The technical stack and architecture suggest a developer-focused, native macOS application with strong emphasis on safety, persistence, and modularity.

• Lattice is described as an early open-source software.
• It was submitted to the OpenAI 2026 hackathon.
• The author states that it is “real and runnable today.”
• No evidence of:
  • Users
  • Customers
  • Downloads
  • Community engagement
  • Revenue
  • Product adoption

Not evidenced: No traction or maturity indicators are provided.

• The description does not mention any competitors.
• It is implied that Lattice addresses fragmentation in AI coding workflows, but no specific market players or tools are named.
• The author references:
  • Codex
  • OpenCode
  • Grok Build ACP
  • Hermes ACP
  • Ollama
  • Apple Foundation Models

Inference: Lattice appears to be positioned in the space of AI coding agents and developer tooling, but no competitive landscape is described.

• Single-person project: The entire team consists of one individual.
• No commercial traction or revenue: No evidence of users, customers, or monetization.
• Unproven adoption: The project is early-stage and submitted to a hackathon; no real-world usage is evidenced.
• Open-source only: No clear path to monetization or product evolution.
• High technical complexity: The architecture involves concurrency, sandboxing, and model discovery — all of which are risky for a solo developer.
• No third-party validation or testing: All development was done by the author with GPT-5.6 as a collaborator.

Inference: The project is in an early prototype phase with no commercial viability or traction demonstrated.

1. What are the actual use cases for which developers are using Lattice today?
2. How does Lattice plan to evolve beyond its current open-source, hackathon-level prototype?
3. Are there any early adopters or users who have provided feedback?
4. What is the long-term roadmap for monetization or commercialization?
5. How does Lattice handle model availability and runtime failures in practice?
6. What are the actual limitations of the current architecture that could prevent scaling?