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 puts each person's own slice of the graph on their own device, offline-first. Facet — the personal client built on it — turns that slice into the whole app: what you can see and do arrives as data, not as app releases. Both run today; the hosted demo is Facet, live.
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, 100+ 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.
The hosted demo is live — the real stack over a shared showcase world, reset nightly. Next: throwaway per-visitor instances, so you can install a package into your own world and watch Weaver converge on it in real time, then throw the whole world away.
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.
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 make up-facet # Facet, the personal client → :7810
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.