Capacities vs Anytype vs Logseq: Local-First PKM Tools Compared in 2026

I have a graveyard of abandoned note apps. Most died because they made a quiet trade I only noticed months in: my notes were really living on someone else’s server, in someone else’s schema, and leaving meant an export button that lost half the structure. So when I sat down to seriously compare the local-first and privacy-respecting end of personal knowledge management, I gave each tool real time — weeks, not an afternoon — and I paid attention to the parts that only show up after you have a few hundred notes and actually want to leave.

The three I kept coming back to were Capacities, Anytype, and Logseq. They are often lumped together as “the indie PKM tools,” but they could hardly be more different under the hood. One stores your notes as plain Markdown files on your disk. One stores them as encrypted objects that sync peer-to-peer. One stores them in a polished cloud you do not directly touch. They represent three honest answers to the same question — how do you build a second brain you can trust? — and the right answer depends almost entirely on how your head works.

This is not a roundup of every Obsidian alternative. Obsidian, Tana, and Reflect each deserve their own treatment and I cover them elsewhere. This piece is about these three specifically, because together they map the design space cleanly: outliner, object model, and the spectrum from “files I own” to “cloud I rent.”

Where your data actually lives

Start with storage, because everything else follows from it. This is the axis most reviews skip and the one I now check first.

Logseq is the most literal about ownership. Your graph is a folder of Markdown (or Org-mode) files on your machine. Each page is a .md file; blocks are bullet lines. You can open the folder in a text editor, grep it, commit it to git, or sync it with whatever you already use — Syncthing, iCloud, a private repo. There is no proprietary container. If Logseq the company vanished tomorrow, your notes would be exactly as readable as they are today. For a developer this is enormously reassuring: it is just text, and text outlives apps.

Anytype takes a different but equally principled route. Your data is stored locally as encrypted objects in a local database, and it is end-to-end encrypted. Sync happens over a peer-to-peer network rather than a central server you have to trust with plaintext — and you can self-host the sync node if you want to. The catch is that the on-disk format is not human-readable files you can grep; it is an encrypted object store. You own it and it is private by design, but “open the folder and read it” is not the workflow. Export to Markdown exists for getting data out.

Capacities is the most cloud-centric of the three. Your content lives in Capacities’ hosted backend, and the desktop and mobile apps are clients to it. The core is closed-source. You get exports (Markdown and otherwise), but you do not get a local file tree that mirrors your knowledge base the way Logseq does, and you are trusting the company with your data the way you would trust any well-run SaaS. That is not a knock — plenty of people happily make that trade for a better product — but it is a categorical difference from the other two.

Three mental models: outliner, object, block

The storage difference is mirrored by a difference in how you are asked to think.

Logseq is an outliner first. Everything is a bullet, and bullets nest. You write by indenting and outdenting, and the unit of meaning is the block, not the page. This is wonderful if your thinking is hierarchical and incremental — meeting notes, daily journals, research where you accrete bullets under a topic. Bidirectional links and block references are first-class: you [[link]] to a page or ((reference)) a specific block, and backlinks accumulate automatically. The daily journal is the gravitational center; many Logseq users barely create named pages and instead let tags and links organize a stream of dated entries. If you have ever loved Workflowy or RoamResearch, Logseq’s model will feel like home.

Capacities is object-first, and it is the cleanest expression of that idea I have used. The pitch is “everything is a typed object” — a page is not just a page, it is a Note, or a Person, or a Book, or a custom type you define, each with its own properties and its own template. Daily notes still exist, but the organizing principle is that you create things and then connect them. Want every book you have read to share a structure and show up in a gallery? Define a Book object. The result feels less like a text editor and more like a lightweight, opinionated database with a beautiful writing surface on top. It rewards people who like structure and want their notes to behave like records.

Anytype lands close to Capacities conceptually — it is also an object-and-relation model, and the comparison people reach for is “Notion, but local-first and encrypted.” You define types and relations, build sets and collections that query your objects, and assemble a personal database. In practice Anytype feels a notch more like building a system and a notch less like just writing, compared to Capacities’ smoother out-of-box feel. But the payoff is that you get the Notion-style flexibility — typed objects, relational views, queryable collections — without handing your data to a cloud you cannot inspect.

So the structural spectrum runs: Logseq for outline-and-link thinking, Capacities and Anytype for object-and-relation thinking, with Capacities optimizing for polish and Anytype optimizing for ownership within that object camp.

Sync, offline, and the privacy gradient

How these tools sync follows directly from where they store data, and it is worth being precise.

Capacities is online-first. It works best with a connection because the backend is the source of truth; offline support has improved over time but the architecture assumes you are connected, and sync across devices is handled for you transparently as part of the service. For most people most of the time this just works, which is part of the appeal.

Anytype is local-first in the genuine sense: the app works fully offline against your local object store, and sync is an additive layer over an encrypted P2P network. You can run against Anytype’s network or self-host a sync node. Because it is end-to-end encrypted, the sync infrastructure never sees your plaintext. This is the strongest privacy posture of the three by design, and it is the reason privacy-focused users gravitate to it.

Logseq is local-first by virtue of being files on disk — the app reads and writes your folder whether or not you are online. Sync is a separate concern: there is Logseq’s own paid sync service, and there is the do-it-yourself route of pointing your graph folder at git, Syncthing, or a cloud drive. The DIY route is more fiddly and you have to think about merge conflicts on Markdown files, but it means your sync layer is entirely under your control. For a developer who already runs Syncthing or commits dotfiles to git, this is a feature, not a chore.

Extensibility and maturity

If you are a developer, you will eventually want to bend the tool to your workflow, and here the three diverge sharply.

Logseq is the most extensible and the most mature as an open ecosystem. It is open-source, has a real plugin marketplace, supports themes and a query language for building dynamic views over your blocks, and has years of community accumulation behind it — templates, plugins, conventions. If you want to write a plugin, you can. If you want to query “all unfinished tasks tagged #project across my whole graph,” the query system handles it. The tradeoff is that Logseq has at times felt like a project in motion, with notable architectural shifts under the hood; the upside of open development is also the occasional churn of it.

Anytype is open-source as well, which matters for both auditability and longevity — the encrypted, P2P design is the kind of thing you want to be inspectable. Its extensibility story is more about the built-in object/relation system than a sprawling third-party plugin market; you customize by designing types, relations, and views rather than by installing community add-ons. It is a younger ecosystem than Logseq’s, and it shows in the smaller surrounding community, but the foundation is deliberately built for ownership.

Capacities is the polished, closed option. There is no open plugin marketplace in the Logseq sense and the core is not open-source. Extensibility comes through the product’s own features — object types, templates, integrations the team ships — rather than community code. What you get in exchange is consistency and finish: it is the tool that most consistently feels designed rather than assembled. As of mid-2026 it offers a free tier with paid plans for heavier use (roughly in the low-tens-of-dollars-per-month range billed annually for the upgraded tier — check current pricing before you commit, as it changes).

How they stack up

The table flattens nuance, so read it as a starting map rather than a verdict. The single most decision-relevant column is the first one: it is the difference you cannot easily reverse later.

Who should pick which

After living in all three, my recommendations break down by how you think and what you are unwilling to compromise on.

Pick Logseq if you are an outliner thinker who wants real ownership. If your notes are mostly daily journals, meeting bullets, and accreting research under topics — and you want them as plain text you can grep, version, and sync however you like — Logseq is the obvious choice. It is the best fit for developers who already live in git and a terminal, because the storage format is one you already understand. The cost is rougher edges and a sync story you have to assemble yourself.

Pick Anytype if you are a privacy maximalist who wants structure. If the words “end-to-end encrypted, local-first, open-source, self-hostable sync” make you lean forward, and you also want Notion-style typed objects and relational views rather than a pure outliner, Anytype is purpose-built for you. It asks a bit more setup investment than Capacities and its ecosystem is younger, but nothing else here matches its combination of ownership, privacy, and database-style structure.

Pick Capacities if you are a database thinker who values finish. If you want the cleanest object-based writing experience, you think naturally in “things with properties,” and you are comfortable trusting a well-run cloud SaaS the way you trust the rest of your stack, Capacities will feel the most pleasant day to day. You are trading some ownership and openness for polish and zero maintenance — a perfectly reasonable trade if those are your priorities.

If you genuinely cannot tell which camp you are in, the cheapest experiment is this: try to write the same week of notes in Logseq and in one object tool. If indenting bullets feels natural, you are an outliner thinker. If you keep wishing your notes had typed fields and views, you are a database thinker. The tool follows the brain, not the other way around.

FAQ