Project Info
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
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.
Lattice
A native macOS control plane for AI coding agents.
Lattice brings coding harnesses, local models, provider-owned CLIs, permissions, privacy controls, and durable project conversations into one coherent SwiftUI workspace. It is designed for developers who want the power of agentic tools without losing visibility into what is running, where data can go, or which actions require approval.
[!IMPORTANT] Lattice is early open-source software. The repository currently produces an unsigned development build for local testing; it is not yet a notarized production release.
Why Lattice
AI-assisted development is increasingly split across terminal sessions, provider-specific apps, local runtimes, and incompatible approval systems. That fragmentation makes it difficult to preserve context, compare models, understand tool activity, or enforce consistent privacy boundaries.
Lattice is building a single native workspace where developers can:
- Keep project conversations and action history together.
- Connect provider-owned coding harnesses without scraping terminal output.
- Choose between cloud and local execution explicitly.
- Review tool activity and approve consequential actions.
- Discover models based on the providers and runtimes actually available.
- Extend the workspace with user-owned skills and extensions.
Current capabilities
Native workspace
- Durable chats with drafts, queues, continuation, branching, editing, deletion, pinning, and search. The Command-K palette also provides metadata-only quick switching across recent chats with live run/attention state.
- Project-bound working directories and a floating overlay.
- Model and connection management with truthful unavailable states.
- Session import/export with sensitive runtime state removed.
- Recovery surfaces for corrupt or unwritable persistent data.
Execution routes
Every new chat starts with an explicit user choice:
- Code — Build, debug, and ship.
- Work — Research, browse, and act.
- Local — Private models on this Mac.
The model chooser shows only runtime-discovered models for the selected mode. Lattice never automatically switches modes, providers, runtimes, or models.
| Mode | Provider | Integration |
|---|---|---|
| Code | Codex | Lattice Agent (Pi-based) with a Lattice system-instruction and permission extension |
| Code | OpenCode Go/Zen | Lattice Agent (Pi-based) with an explicitly enabled Keychain credential |
| Code | Grok | Grok Build ACP |
| Code | Antigravity | Transcript-driven agy --print |
| Work | Codex / Grok / OpenCode | Unmodified Hermes ACP with an isolated Lattice profile and curated toolsets |
| Local | Apple Intelligence | Foundation Models on supported macOS versions |
| Local | Ollama | Local model catalog, pull/install, and streaming chat |
Lattice Agent (Code) and Hermes (Work) are runtime components, not model providers. Their setup and diagnostics live in a collapsed Connections section. Lattice Agent is Lattice-owned (pinned package under Application Support or a bundled binary) and does not use your personal Pi install or ~/.pi profile. Direct Codex app-server and OpenCode ACP remain compatibility routes for existing chats and v1 archives, but are not offered for new chats.
Authentication is runtime-owned and isolated: Lattice Agent owns the Code Codex login, while Hermes owns the Work Codex and Grok logins. One OpenCode key may be stored in macOS Keychain, but Code and Work access must be enabled and validated separately. Lattice never copies OAuth sessions between CLIs.
Safety and privacy
Each session has explicit execution and privacy choices. What they enforce depends on the selected runtime—inspect Route & safety in the chat inspector before running:
- Ask requests approval for material or non-reversible work when the selected provider protocol can forward permission requests. Antigravity Ask stays plan-only.
- Smart may auto-allow scoped reads only after a structured provider request arrives; writes remain approval-gated when reversibility or scope evidence is incomplete.
- YOLO is explicitly high-trust and may auto-allow provider permission requests. Legacy direct Codex YOLO uses provider
danger-full-access. Live provider tools do not pass throughLocalToolBroker. - Cloud allowed permits connected cloud and local routes.
- Local only blocks routes classified as cloud and keeps execution on available local backends.
Where Lattice applies sandbox-exec, it is a write-containment control, not a confidentiality boundary: reads and network remain allowed. Legacy direct Codex sandbox settings are provider-configured, not Lattice sandbox-exec. Antigravity only receives a provider sandbox option that Lattice does not independently verify. Local chat has no delegated tool loop. Do not treat Local mode as encryption, YOLO as isolation from secrets, or any route as prompt-injection or exfiltration prevention.
Requirements
Run Lattice
- macOS 15 or later
- Apple silicon for the current packaging target
- Optional provider CLIs or local runtimes for the routes you want to use
Build Lattice
- Swift 6 toolchain
- Xcode 26 or a current Swift 6 toolchain with a complete macOS SDK
- Standard macOS packaging tools used by the build script
Build and run
Clone the repository and run:
git clone https://github.com/edgetr/Lattice.git
cd Lattice
./script/build_and_run.sh
The packaged development app is written to dist/Lattice.app and opened automatically.
Additional build-script actions:
./script/build_and_run.sh --debug
./script/build_and_run.sh --logs
./script/build_and_run.sh --telemetry
Verify
Use the repository script so SwiftPM and the Command Line Tools fallback follow the same checks:
# Unit tests, or the core verification fallback
./script/build_and_run.sh --test
# Build and validate the app bundle without launching it
./script/build_and_run.sh --verify
# Tests, bundle verification, and distribution-readiness report
./script/build_and_run.sh --release-check
With a full Xcode/SwiftPM environment, you can also run:
swift test
swift build
Provider credentials are not required for core verification.
Data locations
Lattice stores product data under:
~/Library/Application Support/Lattice/
Notable data includes durable sessions, user-managed extensions and skills, and compatible harness session state. Secrets managed directly by Lattice use macOS Keychain. Provider CLIs retain their own credential stores and terms.
Legacy Nisa identifiers exist only to migrate data created before the Lattice name. New product data and public interfaces should use Lattice naming.
Project structure
Package.swift Swift package definition
Sources/Lattice/ SwiftUI application target
Sources/LatticeCore/ Domain, policy, persistence, and harness logic
Tests/LatticeCoreTests/ Swift Testing coverage
Resources/ Application artwork
script/build_and_run.sh Build, test, package, and verification entry point
script/verify_core.swift Command Line Tools verification fallback
AGENTS.md Repository guidance for coding agents
BUILD_WEEK.md Build Week contribution and evidence log
Development principles
- Unavailable providers must remain visibly unavailable; never simulate success.
- Prefer structured provider protocols over terminal scraping.
- Keep permission, privacy, and sandbox claims narrower than the implementation.
- Never commit credentials, provider sessions, user transcripts, or generated build products.
- Preserve user control over consequential actions and cloud routing.
- Keep core policy testable without provider accounts.
See CONTRIBUTING.md for the development workflow and SECURITY.md for responsible vulnerability reporting.
Product research that informed the chat quick switcher is recorded in docs/research/t3-code-comparison.md.
Roadmap
Lattice is moving toward a dependable daily workspace for multi-agent software development. Near-term work includes deeper structured harness integrations, clearer cross-agent planning and review, richer extension APIs, improved onboarding, broader accessibility coverage, and a signed/notarized distribution path.
OpenAI Build Week
Lattice is being developed during OpenAI Build Week with Codex and GPT-5.6. Build Week contributions will be kept in dated commits and documented in the repository so the role of Codex, GPT-5.6, and human product decisions remains clear.
The running contribution record and submission checklist live in BUILD_WEEK.md.
License
Lattice is available under the MIT License.
Analysis
View
Metric
- 173
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- SwiftIn code
- OllamaClaimed
- OpenAIClaimed
1 of 3 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
- CodexConfig
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
3.8 MB
Source files
263
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
edgetr/Lattice
274 files · 5.2 MB · @ f445576
Structure
Application logic
185 files · 68%Domain rules, services and shared utilities.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- Swift97%
- Markdown3%
- Shell1%
- YAML0%
Share of indexed source by file size. Binary and vendored files are excluded.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.