Lattice

The Lattice product

From a note to a working system.

Lattice combines the immediacy of a local knowledge tool with structured data, reviewable agent work, compute, and automation—without turning every resource into the same kind of block.

Get early access Explore the workspace
Lattice resource constellation Pages, canvases, tables, datasets, notebooks, and tasks joined in one local workspace. Page Canvas Table Dataset Notebook Task Workspace

Pages & capture

Fast enough for a thought. Structured enough for a body of work.

Write in a focused Markdown editor with headings, lists, code, diagrams, images, and durable wiki links. Quick Note opens from anywhere; local dictation can turn speech into final text without sending audio to a cloud service.

  • Autosave with revision guards and visible external-edit conflicts.
  • Backlinks, tags, command search, and optional on-device semantic retrieval.
  • Card and interactive embeds for pages, data, files, tasks, and artifacts.

Learn pages and capture →

Field notes.mdSourcesInspect
Research / Field notes

Patterns worth keeping

A local note can stay simple, then connect to [[Customer themes]] and the table below.

Captured locally · indexed · linked
CRM.data / Interview themes12 records

Canvas & composition

See the shape of the work without losing its source.

Canvas is a spatial layer over real resources, not a second place to copy them. Add sticky notes, connect ideas, place workspace files, and open the original resource from the board.

  • Pan, zoom, select, resize, connect, and move nodes smoothly.
  • Keyboard-accessible outline gives every canvas a linear reading order.
  • JSON Canvas keeps placement portable outside Lattice.

Learn canvas →

Page .md Notebook .ipynb Canvas .canvas Table SQLite Dataset Parquet File native COMMAND CORE

Pages, files, data, and code compose without becoming one format

Tables & analytical data

From a simple list to a real local application.

A Lattice Table is SQLite-backed from the start. Enter records in a fast grid, then add alternate views, forms, relations, formulas, lookups, and rollups. When scale or analysis calls for it, Parquet datasets open through DuckDB and Arrow.

  • Grid, list, board, gallery, calendar, form, and interface surfaces.
  • Perspective exploration, Vega-Lite charts, profiles, plans, and maps.
  • Bounded, cancellable queries instead of loading an entire dataset into the UI.

Tables guide · Datasets guide →

1K 100K 10M 1B 50K Hosted table A 250K Hosted table B 5M Lattice SQLite app 1B Lattice Parquet + DuckDB rows handled locally — log scale · illustrative

The same local data can feed grids, charts, maps, and interfaces

Agents, notebooks, tasks & workflows

Make the workspace executable—and keep every action inspectable.

Run Jupyter notebooks with a native Python kernel or Pyodide, package repeatable code as local tasks, connect steps in bounded workflows, and review transaction proposals before agent-generated changes reach canonical files.

  • Run or interrupt individual notebook cells and persist outputs to ipynb.
  • Task manifests declare runtime, entrypoint, inputs, outputs, and limits.
  • Workflow runs expose step logs, status, recent executions, and proposals.

Explore agents and local compute →

Desktop GUI CLI Local API MCP Agents & scripts Command + Transaction *.md *.sqlite *.parquet *.canvas

People, tools, and agents meet at the same governed command core

Local-first & open-native

Your workspace remains useful without Lattice.

Canonical resources live in a normal directory. Lattice adds editing, search, history, previews, and orchestration around those resources; it does not hide them in an account or proprietary cloud database.

  • Works offline; network services are optional capabilities.
  • Finder, Git, backup software, editors, and scripts can use the same files.
  • CLI, local API, and MCP foundations make the workspace legible to other tools.

See formats and interoperability →

Engineering Workspace/ lattice.yaml manifest README.md markdown Notes/ pages CRM.data/ data app · sqlite Usage.dataset/ parquet · duckdb Strategy.canvas json canvas Analysis.ipynb jupyter Architecture.ink/ ink · arrow .lattice/ derived

Canonical work in ordinary files; rebuildable operational state stays separate

Lattice Cloud

Pay for the service, not access to your own work.

The local app and open formats are the foundation. The planned paid cloud layer adds managed operations that are genuinely useful across devices and teams.

Available locally

Free local app

No account required. Your computer remains the primary runtime and your directory remains canonical.

  • Local editing and search
  • Canvas, tables, analytics, notebooks
  • Tasks, workflows, CLI, API, and MCP
  • Local backups and self-managed storage
In development

Optional managed cloud

A future paid service for people who want Lattice to operate the connected layer.

  • Encrypted personal sync
  • Sharing, comments, and presence
  • Managed backups and retention
  • Team controls, hosted jobs, and publishing
Local workspace with optional cloud sync A local file workspace remains canonical while an optional managed cloud connects devices and collaborators. Local workspace · always yours Lattice Cloud · in development sync · sharing · backups · teams

Cloud capabilities are product direction, not currently available service. Local formats, export, CLI, and self-hosting are not intended to become plan-gated.

Explore the connected Lattice Cloud layer →

Available surfaces

A broad local workspace, already taking shape.

These surfaces are available in the local app today; future cloud capabilities are labeled separately.

Notes & knowledge

  • Markdown editor
  • Quick Note
  • Local voice dictation on macOS
  • Wiki links & backlinks
  • Keyword + optional semantic search
  • Images, Mermaid & resource embeds

Structure & data

  • Editable JSON Canvas
  • SQLite-backed tables
  • Grid, list, board, gallery & calendar
  • Forms & record detail
  • Relations, formulas, lookups & rollups
  • CSV and tabular import

Analysis & compute

  • Parquet datasets
  • DuckDB queries
  • Perspective data exploration
  • Vega-Lite charts
  • MapLibre maps
  • Native + Pyodide notebooks

Programmability

  • Local task runner
  • Bounded workflows
  • Transaction proposals
  • Sandboxed HTML artifacts
  • Multi-component interfaces
  • CLI, local API & MCP foundations
Coming next: richer cross-resource dashboards, deeper lineage and automation, publishing, plugin packs, and the optional sync/collaboration service. See the cloud direction →