What is a local-first AI workspace? A founder's guide.

Updated 2026-04-27 · 14 min read

The phrase "local-first" gets used loosely. People say it about apps that just have an offline cache. People say it about apps that store a copy of your data on disk while keeping the source of truth in the cloud. Both of those are useful, but they're not what "local-first" originally meant, and they're not what matters when the data in question is your business plan, your customer interviews, or your draft pitch.

I'm going to walk through the strict definition, why it matters more for AI tools than for any previous category, what trade-offs you're actually accepting, and which tools currently qualify. I built Projelli on the strict definition, so I have a stake in this. I'll be specific about where Projelli wins and where it doesn't.

What "local-first" actually means

The canonical definition comes from Ink & Switch's 2019 essay "Local-first software". The seven properties they laid out are still the right test. Concretely, a tool is local-first if all of the following are true:

1. Your data lives on your device. Not "is cached", not "is mirrored". The authoritative copy is in a folder you can navigate to in Finder or File Explorer.
2. The format is something a different tool can read. Plain text, Markdown, JSON, CSV, or another open format. Not a proprietary binary blob you can only read with the original tool.
3. The app works without a network. All editing, navigation, search, and history works offline. Network is only required for specific online features (in our case, AI calls).
4. The cloud is optional. If you choose to sync, you choose how. Dropbox, iCloud, Syncthing, a USB stick. The tool doesn't require the cloud to function.
5. You can read the data without the tool. If the company that makes the tool disappears tomorrow, you still have your stuff. You can grep it. You can open it in TextEdit. You can write a script to migrate it.
6. Collaboration is opt-in, not assumed. If you ever collaborate, you do it through your sync layer (a shared Dropbox folder, a Git repo). Not through the tool's server.
7. Privacy and ownership are the default. The tool doesn't ship your text to a server unless you ask it to.

This is a strict test. Most "local-first AI" tools fail at least one of these properties. That's not a value judgment, it's just useful to know.

Why local-first matters specifically for AI

For most software categories, local-first is a nice-to-have. For AI tools, it's a different conversation. Here's why.

The work you do with AI now is the work you used to do alone in a notebook. That includes:

• Drafting your business plan and pitch deck
• Synthesizing customer interviews and figuring out what they tell you
• Modeling pricing strategy and revenue forecasts
• Working through hiring decisions and team conflicts
• Sketching the next product feature in conversational form
• Writing the email you'll send to your one investor about a hard month

If your AI conversations live in someone else's database, three things are true:

One. Your data is subject to that company's retention policy, training-data policy, and access policy, all of which can change. They've changed before, and they'll change again. Notion, OpenAI, and Anthropic have all updated their data terms more than once in the last two years.

Two. You can't easily move it. Even with export tools, the format is usually a JSON dump that no other tool can directly read. If you decide later that you want to use a different AI workspace, you start over.

Three. You can't search across years of strategic thinking the way you can across a folder of Markdown files. The lock-in compounds: the more you put into the tool, the more you depend on it, the harder it is to switch.

The strict version of local-first inverts all three. Your retention policy is your file system. Your export is "cp -r". Your search is grep, plus whatever full-text search the workspace tool layers on top.

The hybrid: local-first data, cloud AI

Local-first AI doesn't mean "the AI runs on your laptop." It usually means "your data lives on your laptop, and the AI runs wherever AIs run today, which is in the providers' clouds."

The architecture that emerges is hybrid:

• Your files: on your machine, in Markdown
• The workspace app: on your machine, with no server-side state
• Your AI keys: on your machine, encrypted, in the OS keychain or an encrypted file
• The AI request: from your machine, directly to Anthropic / OpenAI / Google, using your own key
• The AI response: back to your machine, written into a Markdown file

Critically, the workspace tool's servers are never in the path. There's no Projelli account. There's no Reflect account. There's no Notion account. The only servers your data ever touches are the AI provider's, and only for the specific text you chose to send.

This pattern goes by a couple of names. The most common is BYOK, "bring your own key", which I covered separately at /byok-ai. Whatever you call it, this is the architecture that lets the workspace be honestly local-first while still doing useful AI work.

For local AI inference (where even the AI runs on your machine via tools like Ollama or LM Studio), you can go fully off-cloud. Quality is closing on cloud models for many tasks but isn't there yet for the strategic-thinking work most founders do. The hybrid is the realistic option for now.

The honest trade-offs

I'm going to name three real trade-offs of local-first AI tools so the picture is honest.

1. Setup friction

You bring your own AI key. That means signing up at Anthropic / OpenAI / Google AI Studio, getting an API key, and pasting it once into the tool. It's about five minutes. It's also five minutes more than ChatGPT.com asks you for. Some people will bounce on this, and that's fine, they're not the target user.

2. No built-in cross-device sync

If you want your workspace on your laptop and your iPad, you put the workspace folder in Dropbox or iCloud and let those sync it. This works, has worked for years for Obsidian and similar tools, and is more reliable than most apps' built-in sync. It does mean one extra setup step.

3. No built-in collaboration

Local-first tools are single-user by design. You can share files (Git, Dropbox, email) but the tool doesn't have a real-time multi-cursor experience. For solo founders this is fine. For teams, it isn't. The distinction is intentional, and it's why you'll often see local-first tools positioning explicitly for individual users.

If you need a team workspace, the right tool is probably Notion, Linear, or a document collaboration tool. If you need an individual workspace where the data is yours, local-first is the right shape.

Which tools are actually local-first AI workspaces

Here's the honest landscape. I'm using the seven-property test from above. A tool fully passes if all seven are true; it partially passes if some are true.

Tool	Local data?	Open format?	Works offline?	Cloud optional?	Verdict
Obsidian + AI plugin	Yes	Markdown	Yes	Yes	Local-first if you assemble it
Logseq	Yes	Markdown / EDN	Yes	Yes	Local-first; AI is plugin-driven
Projelli	Yes	Markdown	Yes (except AI calls)	Yes	Local-first AI workspace out of the box
Notion AI	No	Proprietary	Cache only	No	Cloud workspace; not local-first
ChatGPT, Claude.ai, Gemini	No	N/A	No	No	Cloud chat; not local-first
Reflect, Mem.ai, Tana	No	Export available	Cache only	No	Cloud notes with AI; not local-first
Bear, Apple Notes	Yes (sort of)	SQLite, proprietary	Yes	Yes	Local data, but no real AI integration
Standard Notes	Yes	Plain text / encrypted	Yes	Yes	Local-first notes; no built-in AI

The tools that fully qualify as local-first AI workspaces today are Obsidian (with AI plugins you assemble yourself), Logseq (with similar plugin assembly), and Projelli (where the AI is built in). Bear and Standard Notes are local-first notes but don't really do AI as a first-class feature.

Notion AI, Reflect, Mem.ai, Tana, ChatGPT, Claude.ai, and Gemini are all useful tools, but they're cloud-first. Calling them "local-first" because they have an export button is stretching the term past usefulness.

The case for indie founders specifically

I built Projelli for indie founders because that's the audience the trade-offs land best for.

An indie founder spends their day generating strategic documents that are sensitive to themselves and their business. Pitch deck drafts. Customer interview transcripts. Pricing experiments. Internal financial models. Honest weekly reviews about what's working and what isn't.

For a knowledge worker inside a large company, this content lives in Notion or Confluence, where the company's IT policy and SSO and audit logs are doing the safety work. For an indie founder, there is no IT policy. The decision about where strategic documents live is the founder's, and it's usually made implicitly when picking a tool.

Local-first puts that decision back in the founder's hands. The trade-off, the setup friction, is one-time. The benefit, that ten years from now you still have your archive in a format that any tool you might want to use can read, is permanent.

It also matches how indie founders already work. Most already have a folder of project notes in Markdown somewhere. Most already use Dropbox or iCloud. Most are AI-native by 2026 standards. The mental model of "my files, my keys, my machine" is already familiar.

How Projelli does this

Projelli is a desktop application (Tauri 2 + React) that runs on Windows, macOS, and Linux. The shape is exactly the hybrid I described above:

• You pick a workspace folder on first launch. Anywhere on your disk. Could be in Dropbox, could be on a USB stick.
• Every AI conversation produces a `.aichat` file in that folder. Open it in any text editor; it's structured Markdown with a YAML frontmatter.
• You bring your own API key for Anthropic, OpenAI, or Google. The keys live in your OS keychain. AI requests go directly from your machine to the provider, never through Projelli.
• 15 founder-specific workflow templates are built in: pitch deck, customer interview, financial projections, weekly review, MVP scope, go-to-market, investor update, board prep, first hire, and more. Each template runs against your own files, on your own machine.
• Wiki-links, backlinks, full-text search, version history all work locally. Everything indexes from the same folder structure.
• One-time pricing. $49 Pro, $99 Lifetime, with a $29 Founder's Lifetime tier capped at the first 100 buyers. No subscription, ever. Sold via LemonSqueezy.

The full feature reference is at FEATURES.md in the repo. Source code is open at github.com/projelli/projelli.

Frequently asked questions