Locality turns the knowledge in Notion, Slack, Google Docs, Linear, and other work apps into a private, live-synced filesystem workspace for you and your AI agents.
Your company's knowledge already exists. It lives across documents, messages, issues, meetings, and calendars. But every app exposes that knowledge through a different interface, and every agent integration adds another API, tool schema, authentication flow, and runtime dependency.
Locality makes those systems feel local. It presents their content as local files and folders while keeping the original applications synchronized. People, editors, scripts, and agents can use the filesystem tools they already understand.
This is not a one-time export and it is not another knowledge silo. Your connected apps remain the systems of record; Locality gives them a shared, local file-based interface.
MCP is useful for making individual tools callable at runtime. Locality takes a different approach for knowledge-heavy and production agent workflows: it prepares a unified filesystem workspace before the agent begins, so the agent can discover, search, and combine information with normal file tools.
In our evaluation of 20 cross-application scenarios using Notion, Slack, Linear, and source repositories, agents working through Locality completed tasks faster, used fewer tool calls, cost less, and produced the preferred result more often.
Read the full methodology and results →
With files, agents can use fast, composable operations such as search, filtering, parallel reads, and scripts across every connected source. They do not need to reason through a different tool surface for every application or place broad app credentials inside the agent sandbox.
|
Get the latest desktop release from the Locality website. The app keeps itself up to date. |
Choose a source such as Notion, Google Docs, Slack, Linear, Gmail, Calendar, or Granola and approve the access you want Locality to use. |
|
Your connected knowledge appears as files and folders that work with Finder, editors, search tools, scripts, and terminals. |
Open the workspace with Codex, Claude Code, or another filesystem-capable agent. Live Mode keeps active work fresh and safely synchronized. |
Install Locality, connect your workspace, and use it directly from Claude.
| For you | For your agents |
|---|---|
|
|
- Build a personal knowledge base from the work already spread across your apps.
- Give agents better context across documents, conversations, issues, and meetings.
- Research across sources without copying and pasting content between tools.
- Edit through files and synchronize supported changes back to the original app.
- Use existing workflows built around editors, shell tools, scripts, and coding agents.
- Keep collaboration intact because teammates can continue working in the source apps.
| Your apps Notion, Slack, Linear, Google, Granola |
⇄ | Locality Connect, project, validate, synchronize |
⇄ | Local files Markdown, folders, metadata, attachments |
⇄ | You + agents Editors, search, scripts, Codex, Claude |
Locality maintains a synchronized view of connected content and exposes it through the operating system's filesystem. Opening or searching a file can hydrate current content on demand. Supported edits are validated and translated back into operations for the source application.
The remote app keeps its identity, structure, permissions, and collaboration model. Locality keeps durable local sync state so it can distinguish remote changes, local changes, and conflicts rather than blindly overwriting either side.
For the desktop app, your workspace and sync state live on your machine. The desktop client talks directly to each connected app's API for content and synchronization. No Locality backend or middleman sits between you and your apps, and the desktop app does not collect or transmit usage telemetry.
Locality does not require moving your knowledge into a new proprietary knowledge database.
|
Direct connections. No telemetry. Your desktop client communicates directly with your connected apps. Your workspace content and activity are not routed through a Locality backend or telemetry service. |
|
|
Local workspace Connected content is presented through files you can inspect and use with the tools you choose. |
Protected credentials App credentials live in the operating system credential store; Locality keeps only credential metadata in its local database. |
|
Your apps remain authoritative Locality preserves remote identity and structure instead of asking you to migrate your team's knowledge into another silo. |
Safe synchronization Locality checks the current remote version before writes and pauses when a conflict or risky change needs review. |
You decide which sources to connect, which content to expose, and which agents or local tools can access the resulting workspace.
| Feature | What it means |
|---|---|
| Live Mode | Keeps active files fresh, automatically synchronizes safe edits, and pauses when human review is needed. |
loc command-line tool |
Lets agents, scripts, and terminal workflows locate, inspect, refresh, review, and safely update mounted content. |
| A filesystem for every app | Work with one familiar interface instead of learning a new API or agent tool schema for each source. |
| Two-way synchronization | Supported edits can flow back to the source app while remote updates flow into clean local files. |
| Conflict-aware writes | Locality compares local, remote, and last-synced state before applying mutations. |
| Agent-ready workspaces | Generated AGENTS.md and CLAUDE.md guidance helps coding agents understand mounted content and safe write behavior. |
| Fast local discovery | Agents and people can use familiar search, filtering, scripting, and editor workflows across sources. |
| On-demand content | Large workspaces can appear locally without eagerly downloading every file before you begin. |
| Reviewable changes | Inspect pending changes and planned source operations before applying sensitive updates. |
Live Mode is Locality's background synchronization loop. It prioritizes open, recently used, and locally changed files instead of continuously crawling an entire workspace.
When a change is clearly safe, Live Mode can synchronize it automatically. When Locality detects concurrent edits, unsupported operations, destructive changes, or remote drift that needs a decision, it pauses and asks for review instead of guessing.
The loc command-line tool lets agents, scripts, and automated workflows interact
with Locality mounts using the same sync and safety guardrails as the desktop app.
See the CLI reference for the complete command surface.
Locality Cloud is a separate product from Locality Desktop. It maintains a pre-synced, cached state of approved company knowledge and mounts it into an agent sandbox immediately when a sandbox starts. Agents get the same filesystem-native experience without waiting for source APIs, while teams get centralized, fine-grained access control and keep provider credentials out of the sandbox.
If you are building production agents and want to use Locality Cloud, contact us.
| Source | Local workspace | Write support |
|---|---|---|
 Notion |
Pages, databases, properties, and supported media | Conservative page, block, property, and database-row updates |
 Google Docs |
Documents and Drive-backed structure | Conservative document updates |
 Google Calendar |
Primary-calendar events | Reviewed event-draft creation |
 Gmail |
Messages and threads | Reviewed Gmail-draft creation |
 Linear |
Teams, issues, and issue context | Supported issue edits |
 Slack |
Channels, private channels, DMs, group DMs, and users | Read-only |
 Granola |
Meeting summaries and transcripts | Read-only |
Connector capabilities are intentionally explicit. Locality does not pretend every shape in every source can be edited safely. Unsupported or lossy operations pause before mutation rather than silently degrading the original content.
- Files are the universal interface. Editors, scripts, operating systems, people, and agents already know how to work with them.
- Connected, not exported. A local workspace should stay linked to the place where teams already collaborate.
- Your context should outlive any agent. Knowledge should not be trapped inside a model provider, chat session, or proprietary agent memory.
- Inspectability beats hidden magic. You should be able to see the files, changes, sync state, and evidence an agent used.
- Safety comes before automation. Locality automates obvious operations and pauses when the correct action requires human judgment.
- Bring your own agent. Locality is a workspace layer, not an AI-provider lock-in.
Is Locality an export tool?
No. Exports become stale snapshots. Locality keeps a synchronized local projection while preserving the connected app as the system of record. If you do want to export an app workspace as ordinary files, pass
--projection plain-files when mounting it with loc.
Does Locality replace Notion, Slack, Google Docs, or Linear?
No. Your team can continue collaborating in those apps. Locality adds a filesystem interface for local tools and agents.
Does Locality replace MCP?
Not in every situation. MCP is useful for invoking tools and perfoming actions dynamically. Locality is designed for workflows where agents need broad, repeated, cross-source access to knowledge. It can replace many app-specific retrieval calls with a prepared filesystem workspace. See our Locality vs. MCP evaluation for the tradeoffs and results.
Which agents work with Locality?
Any agent that can read files can use a Locality workspace. Locality includes generated guidance for agents such as Codex and Claude Code.
Can agents write back to connected apps?
Yes, for supported connectors and operations. Locality validates changes, checks for remote drift, and pauses risky or conflicting writes for review. Read-only connectors remain read-only.
Where is my data stored?
The desktop workspace, sync metadata, and hydrated content are stored locally. Credentials are protected by the operating system credential store. The original content also remains in the connected source application.
Build and test Locality from source
The root Makefile is the shortest path into the project:
make setup
make build
make testFor local development:
make dev-tauriUseful engineering references:
Run make help for the complete list of build, test, lint, packaging, and release targets.
- Read the documentation.
- Download the latest desktop release.
- Report bugs or request features through GitHub Issues.
- Talk to us about an agent workflow through the Locality contact page.
Locality is available under the Apache License 2.0.