A business never stops changing — its software rarely keeps up. Lattice runs the whole business on one living graph, where new capabilities install like apps and evolve while everything runs — safe for humans and AI agents to change together.
Most platforms freeze a business into someone else's data model — every new idea becomes an integration project. Lattice is the opposite bet: your business runs on its own instance of one living graph, and every capability on it is a package your team authors, reviews, reverses and evolves — AI-assisted — while the business runs. We build and operate the platform; you grow what runs on it.
A new lease rule, membership tier or access policy is authored as a package — by a person or an AI agent — and passes human review and deterministic validation before it is ever real. Intent plus review, not intent alone.
One writer, one write path. Who submitted a change, which capability allowed it and what it touched is all recorded — so you can watch it live, scrub the history, and roll it back. Nothing mutates state in the dark.
Install or upgrade a package and its entities, operations, lenses and roles come online in the running platform — no restart, no migration window. The system grows a capability instead of being taken down to change one.
# a capability is just a declaration — authored, reviewed, versioned, reversible entities: - unit # vtx.unit.<id> — aspects: .address, .listing operations: - SetListing # write path: operations → the one Processor - AssignUnitOwner lenses: - availableListings # read path: CDC → Refractor → NATS-KV - renewalsRead # Postgres + RLS: tenant OR landlord may read a row
A package declares entities, operations, lenses, permissions and orchestration. Install one and your instance grows a capability. Install two and they already know each other — they share the graph.
Enterprise-grade coherence — one model for the whole business — without the enterprise price tag, the year-long rollout, or the army of integrators.
The same pattern repeats up the stack: people set direction and hold the gates, AI does the heavy lifting — and all of it works because the graph explains itself.
Lattice itself is designed, built and operated by an AI agent organization, with one human principal ratifying every design and every contract change. The showcase verticals — leasing, clinic, café, wellness — are working references that prove the patterns, not products for sale. The paper trail is public.
Your business runs on its own Lattice instance. Your people — AI-assisted — author and evolve the packages and verticals it actually needs, web and mobile, against a graph that describes itself: entities, operations, permissions, all discoverable. New ideas become installed capabilities, not integration projects.
Customers get clean front-ends today — and a graph their own assistants can safely act on: every operation is typed, authorized and attributed, so booking, renewing and approving can be delegated without fear. Edge Lattice — now in build — puts each person's own slice of the graph on their own device, offline-first. Facet — the personal client in build on it — turns that slice into the whole app: what you can see and do arrives as data, not as app releases.
Underneath, it's one graph of facts — vertices, their data in aspects, relationships as links — and everything is a package. Two paths, no exceptions: writes are operations through one writer; reads are lens projections. Every other component is a client of those two paths.
Two durable streams are the rails everything rides. External actors reach the graph only through the Gateway, which authenticates each one and stamps an unforgeable identity on every write. Writes land on core-operations; the Processor commits them and emits core-events, which the Refractor projects into lenses. Loom, Weaver, Bridge and the Chronicler are clients of those same two streams — they consume events and submit operations, exactly as your apps do.
Most systems tell the computer how, step by step. Lattice Weaver lets a package declare what should be true — a goal, expressed as a lens over the graph — and then makes it so. It watches for the gap between the world and the goal, and closes it.
The important part: Weaver doesn't run a fixed playbook. Given a goal and the operations a package exposes, it plans — searching for the sequence of operations that reaches the goal, dispatching the next step, watching the result, and re-planning as reality changes. It carries no business logic of its own; every goal and every operation is package data. The same engine drives a lease to renewed, an unpaid balance to settled, an orphaned document to shredded.
Give it a target outcome and the operations available; Weaver synthesizes the ordered steps that reach it, dispatches the next one, and re-plans when it completes. The lease-renewal you see in the demo below is a real goal-authored target running this way.
A goal can declare rate budgets; Weaver paces its actions with a priority-fair scheduler, so a surge of work can't storm the system and urgent rows go first. Convergence, throttled to what the platform can absorb.
When two goals would ping-pong the same data — each undoing the other — Weaver detects the oscillation and freezes both, surfacing the conflict to an operator instead of corrupting state in a silent loop.
For example: one mixed-use building — homes, a clinic, a café, a wellness studio. Toggle its packages, then switch personas. It's the same graph every time — each persona sees only their projection of it. That's the security model, not a visualization trick: access is a lens.
Lattice's continuous improvement runs as an autonomous agent org: agents survey demand, design features, build them, and hunt each other's bugs — with a human ratification gate on every design and every frozen contract. It's the top layer of the same pattern the platform offers your team: AI does the work, humans hold the gates. And it isn't a marketing claim — the paper trail is in the repository.
Those steps are played by a small cast — most of them one AI architect wearing several hats, with a human holding the gate.
Three independent review lenses — a blind hunter that sees only the diff, an edge-case hunter, and an acceptance auditor — run on every substantial change. Frozen contracts can only be amended by a staged, human-approved diff. The planning boards, 90+ design documents, and every ratification decision are versioned in the open repo.
Plenty of tools now make it safe for AI to write your app's code. Lattice makes it safe for AI to operate the business itself — the same graph, one writer, a human ratifying every change.
A platform you can run today, with the roadmap in the open. The "not yet" column is deliberate — it's what makes the "today" column trustworthy.
What's next is already specified and ratified — sequenced, not shipped. Like everything else, the roadmap lives in the public repository.
A private, offline-first copy of just your own data, on your device. Edits apply instantly and reconcile by revision when you reconnect — while the cloud stays the single source of truth. The read loop, optimistic writes, per-identity connection confinement and on-device key sessions have shipped; the in-browser node — the same engine compiled to WebAssembly — is ratified and in build.
One app whose only hardcoded behavior is signing in. Which services exist for you, what they permit, the forms they need, the tasks waiting on you — all of it arrives as data over your personal lens, rendered by a fixed widget vocabulary. Wire a new service into the building and it appears in residents' apps — zero app change. The renderer already runs against the dev stack; sign-in and the in-browser node are in build.
Horizontal sharding across cells and high-availability clustering — designed and ratified, deliberately deferred until a production-scale driver exists. The architecture already assumes it; the single-node build doesn't need it yet.
Today's demo is a faithful simulation. Next: a hosted, read-only slice of the real stack — then write-enabled, throwaway instances where you submit an operation and watch Weaver converge in real time.
The demo above is a simulation. This is not:
# requires Docker + Go git clone https://github.com/asolgan/lattice cd lattice make up-full # kernel + orchestration + packages + Loupe → :7777 make up-loftspace # LoftSpace vertical → :7788 make up-clinic # Clinic vertical → :7799 make up-cafe # Café vertical → :7801 make up-wellness # Wellness vertical → :7802
What you'll see:
Source-available: cloning and running locally for evaluation is welcome — see the LICENSE for exact terms.
Lattice is source-available, not open source. The code is public to read, run locally, and evaluate; all other rights are reserved. That's a deliberate posture — the platform's value should be legible without being given away.
If what you've seen maps to something you're building — commercial licensing, a design partnership, or acquiring the IP outright — I'd like to talk.