It reads repository instructions. It calls a remote service for durable memory. It asks another tool for project context. It fetches a methodology, loads documents from a workspace app and searches the previous conversation.
Each source may be useful. Together they turn orientation into a distributed systems problem.
The agent waits on network calls before it understands the work. A missing credential removes part of its operating context. A service outage changes what the agent knows about its own methods. The human cannot inspect the whole environment without visiting the same services through separate interfaces.
Agents need access to remote systems. Their owned working set should already be present when work begins.
The owned working set should be materialized where the agent works before the work begins.
I use local-first for that property.
The working set
The working set contains the durable material an agent needs to enter a piece of work:
- identity and operating conventions;
- reusable methods and domain knowledge;
- current human decisions and unfinished work;
- references to product repositories;
- known routes to external systems.
This material changes, but it does not need live remote truth on every read. The owner should be able to inspect it, version it and reconstruct it without asking several services to agree.
Local-first software research frames local availability as a route to fast interaction, offline use and user ownership. The Ink & Switch essay applies those ideas to collaborative software. Agent environments add another reason: the reader is a runtime that repeatedly rebuilds context at session boundaries.
A local working set gives that runtime a deterministic starting point.
Local-first describes materialization
Local-first does not require a laptop or ban cloud execution. “Local” means local to the place where the work runs.
A desktop agent can read a checked-out Home beside the repositories it uses. A cloud agent can start from a repository snapshot that already contains the owned environment. A container can mount the same sources before the runtime starts.
The important property is materialization before work. The runtime should not have to rediscover stable identity, methods and continuity through live calls each time it wakes.
This gives Home-first a deployment rule:
Owned source
↓ sync, clone or build
Local working set
↓ runtime-native projection
Agent session
Source ownership answers who controls the material. Local-first answers where the runtime can depend on it. Projections adapt it to the interface a runtime expects.
Remote systems still own live truth
GitHub owns issues, pull requests and repository permissions. Slack owns live messages. Notion may own a team database. A customer system owns customer records and authorization.
Agents should reach those systems through their APIs, connectors or MCP servers. The Model Context Protocol standardizes how an application exposes context, tools and resources to a model-facing client. It gives the runtime access to another authority.
Access and environment have different jobs.
Local working set
├── identity
├── conventions
├── methods
├── continuity
└── references to external authorities
External systems
├── live records
├── authenticated actions
└── shared remote state
A Home can record which GitHub repository matters, how the team reviews changes and which capability should inspect a pull request. GitHub still owns the pull request. The agent calls GitHub when it needs current comments or wants to perform an action.
This separation reduces unnecessary calls without caching facts that require freshness.
Authority decides the sync direction
Markdown and Notion make the ownership choice concrete.
If the Home owns a document, local Markdown is the source. A sync process can project it into Notion for reading and collaboration. Humans should edit the source or use an explicit ingestion path that writes changes back under the Home’s rules.
If Notion owns the document, Notion remains the authority. The Home can keep a reference, a local materialized copy and a receipt that records when it was read. The next operation that requires current truth refreshes the copy.
Home owns document
Markdown source → Notion projection
Notion owns document
Notion source → local materialization + receipt
Bidirectional sync without an authority rule creates two plausible sources. The agent then has to guess which version controls the work.
Session recovery needs stable semantic roles
Long conversations get compacted. Sessions end. Another runtime may continue the work later.
Compaction has to summarize material whose roles are often implicit. A method, a tentative idea, a product decision and a generated result may all appear as messages or Markdown files with no stable relationship.
A local-first Home gives those objects names and owners before compaction:
Asset equips future work
Artifact preserves a chosen result
Desk holds personal continuity
Target owns product truth
Binding connects the work to a checkout
The next session can reconstruct the environment from owned sources. A conversation summary still helps, but it no longer carries the whole burden of memory.
This mechanism can improve context consistency and reduce setup latency. It does not guarantee correct reasoning or eliminate hallucinations. Those claims need evidence from controlled use.
The human should read more than they operate
Many agent setups ask the human to maintain runtime files, copy prompts, install provider-specific packages and move generated work between folders. The human spends attention on plumbing.
A source-owned local environment can hide most of that maintenance behind rebuildable projections. The human reads methods, reviews changes, curates results and chooses destinations. The runtime receives the forms it needs.
That division matters outside software development. An administrative assistant should not have to design Skills before using an agent. Domain experts can design a coherent Home for that work, including conventions, methods, tools and review points. The practitioner keeps judgment and receives an environment that already expresses the profession’s working system.
The Home becomes the product through which humans and agents collaborate.
One implementation
Endroit implements this direction with ordinary files, Git and a small CLI.
Its current capabilities, installation and alpha limitations live in the product README. This article keeps the local-first argument independent of one release inventory.
Home-first gives the environment an owner. Local-first makes that environment available where the agent works. Together they let remote tools remain useful without making the agent rediscover its own workplace through them.