Vision

Trellis is built on a simple bet: data should outlive the software that renders it.: Everything else on this page follows from that.

The three gaps

Computing today has three structural problems that no app can fix, because apps are the problem.

The semantic gap

Your data is trapped. A note in one tool, a task in another, a file in a third the same information, three silos, zero interop. Every application is a walled garden that speaks its own dialect and forgets everything the moment you close it.

Trellis dissolves the walls. All data decomposes to EAV triples in a single graph. There are no applications only projections: a kanban board, a spreadsheet, a timeline, and a network diagram are different renderings of the same entities. Change the projection and the view changes. The data stays.

The reasoning gap

The reasoning connecting data to action was never treated as data in the first place. Why a change was made, what alternatives were considered, who approved the exception that context lives in chat threads and people's heads, and it evaporates. AI agents multiply the problem: they decide and act continuously, and their reasoning dies with the session.

In Trellis, reasoning is data. Every decision human or AI is a graph entity linked to its rationale, the alternatives considered, and the files it touched. Crucially, this is recorded in the execution path as changes happen, not reconstructed from logs afterward. You can't bolt provenance on later; you have to be there when it happens.

This is the layer Foundation Capital calls the context graph "a living record of decision traces stitched across entities and time so precedent becomes searchable." Their argument for why incumbent systems of record can't build it "capturing decision traces requires being in the execution path at commit time" is a description of the Trellis op log.

The sovereignty gap

Your data lives on someone else's server. Your identity is a row in someone else's database. Your history belongs to someone else's audit log. You are a tenant in your own digital life.

Trellis puts you back in possession. Your identity is an Ed25519 keypair you generated. Your data is .trellis files on your device. Your history is an immutable causal stream you own. Move everything to another machine nothing is locked in, nothing is held hostage.

Projections, not apps

The core inversion: an app owns its data and rents you a view of it. A projection is the opposite the graph owns the data, and views are disposable renderers over it.

This sounds abstract until you use it. The same set of issues is a board when you're triaging, a timeline when you're planning, a graph when you're tracing dependencies. You never export, never sync, never copy-paste between tools because there is only one substrate, and everything reads and writes it. Trellis Studio, the workspace itself, is a projection with no special privileges.

Agents as auditable peers

AI agents in Trellis are first-class actors with the same identity, op signing, and capability system as humans. No service accounts, no invisible backdoors. An agent's ops are signed with its key, its decisions are traced with rationale and alternatives, and its permissions are governance policies in the graph.

The test we hold ourselves to: can you trace every agent action back to a decision, a rationale, and the alternatives it considered?: If not, the agent is a black box, and the trace is broken.

Design principles

These are decision filters, not aspirations. Each comes with a test, and the test is what keeps it honest.

1. Data over applications.: Applications are projections; data is permanent. Test: does this feature work if the user switches to a completely different projection? If not, the data is trapped don't ship it.
2. Declarative over imperative.: State is derivable from configuration plus operations. Test: can you reproduce a workspace from its config and op log alone? If not, there's hidden state fix it.
3. Append-only over mutable.: History is never rewritten. Time travel is a primitive, not a feature. Test: can you check out any past state and get a consistent snapshot? If not, something mutated in place that's a bug.
4. Sovereignty over convenience.: Users own their data, identity, and compute. Test: can the user move everything to another device with zero accounts and zero vendor involvement? If not, that's lock-in undo it.
5. Agents as auditable peers.: Same identity, same rules, full traces. Test: can every agent action be traced to a decision and its alternatives? If not, fix the trace.
6. Projections over hardcoded UI.: Users control how data renders. Test: could a third party build this same view using only the projection API and public graph data? If not, the view depends on private internals refactor it.
7. Local-first, cloud-optional.: Everything works offline on a single device; sync is additive. Test: disconnect the network and kill all background services. Does the system still function fully? If not, the cloud has become load-bearing roll it back.

Where this goes

The near-term work is visible in the roadmap: hardening the kernel, making projections fully declarative across render targets, and peer-to-peer sync that connects graphs without owning them. The direction is constant: one graph, many surfaces, owned by you.