Lattice

Lattice sees what your organisation/team is missing. It holds every goal, promise, blocker, and assumption in one living graph and surfaces the problems before anyone feels them.

Comment

Inspiration

I run a startup and a small agency at the same time — about fifteen people across two very different contexts. By necessity, I'm the HR person, the PM, the chief of staff, and the one who remembers who promised what to whom. The memory burden alone is ridiculous.

Every tool we tried to outsource that memory to felt dead on arrival. Linear is a ticket graveyard. Notion rots the moment two people stop agreeing on the folder structure. Slack is a firehose. They store what happened; none of them understand what's happening.

What we actually wanted was an AI-native tool that behaves like a quiet chief of staff who's been paying attention — something that replaces the "hey, how's that going? still blocked? who owns this?" follow-ups, understands where the company is headed, and surfaces what the founder is missing, because we already see what's in front of us. Lattice is our attempt at that.

What it does

Lattice is an AI-native team execution memory. You tell it what's happening in natural language — by voice or text — and it:

Interprets the update into structured state: a commitment, a blocker, a request, an assumption, a goal shift. Holds a live model of the team — active goal, open commitments per person, blockers, assumptions, and confidence over time. Nudges the right person when a commitment goes past due, a blocker sits unowned, or an assumption hasn't been revisited. Answers questions from that model in a single dry chief-of-staff voice — "who's overloaded?", "what am I forgetting?" — without restating what you already know. Generates a daily Morning Brief — what changed, what's at risk, what needs a decision — before you open Slack. The entire vocabulary is seven words: intent, commitment, blocker, request, reminder, shift, signal. Not a ticket in sight. People can push back honestly, too — an owner can mark a task "can't do" or "busy until [date]" with a reason, and Lattice respects the deferral so the nudges stop.

How we built it

The shape is deliberately small and opinionated.

Next.js 16 (App Router) + React 19 + TypeScript. One client app; all logic in Route Handlers. Supabase for Postgres, Row-Level Security, Realtime, and Auth (email/password + Google). No custom backend. OpenAI Chat Completions (gpt-5.4-mini) for all language work — interpretation, answering, brief refinement — with JSON response-format where the shape has to be exact, and audio transcription for voice updates. An event-sourced core. Truth is an append-only log of events; the visible "seven primitives" snapshot is folded from that log by a Postgres function, which also detects conflicting claims (two people moving the same due date) automatically. Two prompts, one voice. A shared LATTICE_PERSONA and an APP_KNOWLEDGE ontology constant power interpret, ask, and brief — so nothing drifts. Derive-on-read. Nudges, the Morning Brief, and per-person delivery stats are pure functions over the state graph — no cron, no second table, no sync drift. Multi-tenant teams with roles, email/link invites, join-request approvals, and an email task digest — all enforced by RLS. Deployed on Vercel.

Challenges we ran into

Spatial canvas vs. list. The first version was a beautiful "Team Field" canvas that was genuinely hostile as a daily surface — canvases die at ~50 objects. We cut it to a secondary idea and made the list primary. The hardcoded 0.72. Every commitment was stamped with a fake confidence, so every row looked identical and people read it as "% done." We honored AI-supplied confidence and labeled it "conf" everywhere. Owner inference. The model kept defaulting owners to "me/you." We added an explicit prompt rule ("I/me/self is not an assignment — leave empty") plus inline reassignment. FormData vs. JSON. Voice was silently failing because the auth fetch wrapper forced Content-Type: application/json onto multipart audio, stomping the boundary. One-line fix; half a day to find. RLS self-update. Members couldn't edit their own profile, but a naive policy let them promote themselves. We enforced the invariant in the database, not just the app. A rewrite that went too thin. An event-sourced "lens" rewrite stripped out the feature-rich surfaces. We learned the architecture was right but the UI regressed — so we put the full interface back on top of the new core, and kept the lens as a secondary view.

Accomplishments that we're proud of

Real teams chose it. Within weeks, five early-stage startups adopted Lattice — several running multiple teams — and use it daily to track who's committed to what. It quietly replaced their standup-and-follow-up loop and caught things before they slipped. An event-sourced backend with automatic conflict detection that still presents as a dead-simple list of seven primitives. Derive-on-read analytics — nudges, briefs, and delivery stats computed live from the change log, with zero background jobs. A real multiplayer product — teams, roles, invites, realtime, email — shipped and deployed, not a single-user demo.

What we learned

Derive on read before you store. If state is the source of truth, computing views on demand beats maintaining a second representation almost every time. The ontology is load-bearing. "Commitment, blocker, request, shift, signal" is a better model of how a small team operates than "ticket." Getting the primitives right mattered more than getting the UI right. One voice beats many. A single dry persona across three pipelines was the thing that made it feel like a product. Honest pushback is a feature. Letting people say "can't do, here's why" — and having the system respect it — builds more trust than a tool that assumes everything's on track.

What's next for Lattice

Push delivery. Nudges and the Morning Brief into Slack and email on a schedule — the first real cron, the most-requested gap. Deeper memory. Use the event log as a dataset to surface recurring bottlenecks and team patterns over time. Smarter interventions. Move from suggesting next steps to drafting the actual message or reassignment. Integrations. Pull signal from GitHub, Linear, and calendars so Lattice sees what's happening without being told. Operational surfaces. Lightweight scheduling, meetings, and shift coordination so day-to-day ops live in one place.

Built With

Share this project:

Updates