Your work apps, available as local files.

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.

Website  •  Documentation  •  Locality vs. MCP

Why Locality

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.

Locality vs. MCP

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 started in minutes

_{Install Locality, connect your workspace, and use it directly from Claude.}

One knowledge layer for you and your agents

What can you do with Locality?

• 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.

How it works

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.

Private by design. Yours by default.

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.

You decide which sources to connect, which content to expose, and which agents or local tools can access the resulting workspace.

Features

Live Mode

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.

loc: a command line for agents and scripts

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 for production agents

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.

Connected apps

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.

Our philosophy

• 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.

FAQ

Development

make setup
make build
make test

make dev-tauri

Community and support

• 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.

License

Locality is available under the Apache License 2.0.