The lesson from Obsidian is not markdown. It is that people should own the shape of their thinking.
That is easy to miss because the surface details are so visible. Local files. Wikilinks. Graph view. Backlinks. Plugins. Themes. A folder you can sync with git. Those details matter, but they are not the deepest reason Obsidian works. Obsidian works because it does not force every thought into the same box.
A daily note can stay messy. A permanent note can sharpen into an argument. A project hub can collect the current state. A people note can carry relational context. A literature note can preserve someone else’s idea while linking into your own. The system gives enough structure for connections to compound, but not so much structure that the tool starts thinking it is smarter than the user.
That is the posture AI memory systems need.
The wrong lesson
A shallow version of this argument says, “Use markdown for AI memory.”
Markdown is good. Plain text is inspectable, portable, diffable, and boring in the best possible way. A memory you can read with cat has a different moral character than a memory trapped behind a product API. But markdown by itself is not the point. A folder full of random markdown files can still be a junk drawer.
The better lesson is that Obsidian makes knowledge navigable without making it rigid.
That matters because human knowledge is uneven. Some ideas are polished. Some are fragments. Some are questions. Some are records. Some are private context that should inform action without being sprayed into every answer. Some are project-specific. Some belong to a person. Some belong to a moment and should not pretend to be timeless.
A good memory system needs to hold all of that without demanding that every piece become the same kind of object.
The danger with AI systems is that they love neatness. Give an agent a messy folder and it will want to summarize, categorize, compress, rename, and sand down all the splinters. Sometimes that is helpful. Sometimes that destroys the reason the note mattered.
A vault is not a filing cabinet. It is a thinking environment.
Curated knowledge carries judgment
A curated note is not just data. It is a choice.
When a human links two ideas, that link carries judgment. When a project hub says “current state,” it tells the agent what the human believes is live. When a people note tracks communication style, it is not merely storing facts about a person. It is preserving relational context so the agent does not behave like a forklift in a flower shop.
This is the difference between indexing an Obsidian vault as raw text and understanding it as a curated knowledge base. The links matter. The folders matter lightly. The note types matter. The absence of a link can matter. The fact that something lives in a daily note instead of a permanent note can matter.
Agents need access to that shape.
If Signet connects to an Obsidian vault, it should not treat the vault like a bag of chunks. It should understand backlinks, project hubs, daily notes, literature notes, people notes, and permanent notes as different surfaces. It should know that some notes are sources and some notes are synthesis. It should preserve the human’s structure instead of replacing it with whatever taxonomy the model invented during ingest.
That does not mean the agent never writes. The agent can transcribe, link, index, summarize, and maintain. It can do the bookkeeping. It can notice missing connections. It can update a project hub after a daily note changes the state of the work. That is exactly the kind of labor agents are good at.
But the agent should be maintaining the user’s thinking system, not colonizing it.
Obsidian alone is not enough
The other mistake is pretending a vault can do every job.
A vault is wonderful for narrative knowledge, but agents also need structured operations. They need to query code symbols, filter tasks, inspect source provenance, sort events by time, compare current and superseded facts, and let multiple tools read the same context without stepping on one another.
This is where wiki and structured memory need each other. Obsidian gives the human-shaped layer. Structured stores give the machine-shaped layer. Neither should dominate the other.
A codebase should not have to become a prose essay before an agent can reason about it. A database should not have to become a wiki page before an agent can filter it. A personal vault should not have to become a rigid schema before its links and notes become useful.
This is the real opportunity for Signet. It can let an Obsidian vault remain a vault while still connecting it to structured memory, code graphs, explicit agent memories, and generated views.
The vault becomes one surface of owned context. Not the only surface. Not a toy interface over a hidden database. One honest surface among several.
What Signet should borrow
Signet should borrow Obsidian’s restraint.
Do not make the context layer the whole application. Do not force every user into the same workflow. Do not make the agent’s summary more authoritative than the user’s file. Do not hide the memory somewhere only the product can inspect. Do not over-solve the user’s thinking until there is nothing human left in it.
Borrow the local-first instinct. Borrow the graph of associations. Borrow the idea that links are first-class. Borrow the acceptance that some notes are messy because life is messy. Borrow the plugin-shaped openness, where people can extend the system without waiting for the vendor to bless every use case.
Then add what agents need.
Add structured recall. Add provenance. Add currentness. Add scoped access. Add query APIs. Add codebase indexing. Add secrets. Add cross-harness portability. Add the ability for Claude Code, OpenCode, Codex, OpenClaw, and the next harness to stand on the same owned context without trapping that context inside any one of them.
That is how Signet becomes the Obsidian of AI memory systems without becoming an Obsidian clone.
The goal is not a prettier notebook. The goal is a context layer that respects human-shaped knowledge and gives agents the structure they need to act on it.
Let people keep the shape of their thinking. Let agents help maintain it. Let structured systems make it queryable. Let the user own the whole thing.
That is the part worth building.
