Plants compete fiercely for sunlight. Many build sturdy, woody trunks to reach the sky. Some species are structurally flimsy. They grow as vines that can't hold their own weight. Left alone, they sprawl across the dirt where their fruits rot or get devoured by tiny ground-dwelling pests.
Humans built the trellis, a vertical grid of wood or metal, to help the thing sustain itself so it can sustain us.
This post is about the kind of work that grows like a vine (code, decisions, and the reasoning of AI agents) and the structure that lets it bear fruit instead of rotting on the ground.
30-second version
Trellis is a local-first graph for things that grow but can't hold their own weight. Trellis Studio is the workspace where you tend them. Code, agents, and the reasoning behind every change live in one substrate. Boots with
npx trellis studio.
Vines
Modern software is full of vines.
Code is one. It grows fast, branches in every direction, and would happily eat a hard drive if you let it. It doesn't hold its own shape. What keeps it standing is the structure around it: a filesystem, a version control system, a build pipeline. Take those away and code becomes a pile of plaintext on the floor.
Project history is a vine too. Every change has a reason. Most of those reasons live in PR comments, Slack threads, or somebody's memory. Pick any line of code in a six-month-old codebase and ask why it's there. Most of the time, the answer is on the dirt. Eaten.
AI agents are the newest vine, and the fastest-growing. They generate code, make decisions, take actions. Almost none of that reasoning survives the session. The agent's chat log is the only record, and it's already not enough. RAG-over-chat-history is what happens when you try to grow a vine across the dirt and pretend it's a garden.
Each of these vines has its own little plot of dirt: its own tool, its own format, its own way of getting eaten. The connections between them live in your head.
Trellis is a trellis
Trellis is a structural grid for the things that grow but can't hold their own weight in a software project.
Technically: a local-first, AI-native graph engine. Code lives in the graph as entities. Every change is an op: immutable, content-addressed, causally chained. Every decision (human or AI) is a record with a reason. History is a query, not a scroll. The whole thing lives in a .trellis/ folder you can back up with cp -r.
The substrate doesn't care whether the vine is code or notes or agent reasoning. It just holds it up.
I came to this from
Code Editor & Rich Text. Code entities in a tree, changes as causal steps.
Embedded agents. Agents run inside the workspace. Every tool call is an op, not a chat log.
Decision traces. Capture the why behind every change. Search precedent across past runs.
Idea garden. Abandoned exploration stays searchable and revivable. Lost work isn't lost; it's just dormant.
Semantic diffs. Code-aware patches that understand structure, not lines. Function renamed, not 12 lines changed.
Same graph, six surfaces.
Trellis is an EAV store (entities, attributes, values) plus a link index. Files, decisions, issues, and agent runs are all entities with stable IDs.
.
Takeaways
Code, decisions, and agent reasoning are vines. They don't hold their own weight. Build them a structure or accept that most of them will rot.
The substrate is the durable bet, not the surface. Filegraph's canvas was the photogenic part. The substrate underneath was what was actually general.
Local-first solves "agent memory" better than RAG-over-cloud. Embeddings work for similarity. They don't work for causal claims.- A graph you own beats a vector store you rent.
Filegraph's canvas can come back. As a Studio mode, on a substrate that's done the unglamorous work first.
What's next
Canvas mode. The Filegraph payoff (spatial entity arrangement, projections, voice) but inside the Studio, over the same graph as your code.
Hosted Trellis. For people who don't want to install anything. Local-first stays the default; hosted is for when you need to share the garden.
Broader semantic-patch coverage. Today TrellisVCS handles TypeScript, JavaScript, Python, and Markdown deeply. More languages, more operations.
Multiplayer. Real-time collaboration on a shared graph, with op-level conflict resolution that's actually correct because it's working on structured data instead of lines.
For deeper architecture writeups (the EAV model, semantic patching, the decision-trace schema), separate technical posts are coming.
Docs: . Continuing the work of Filegraph.
SOCIAL SHARE CARD GENERATOR