Mod

Claude Code

Codex CLI

Cursor

🦞OpenClaw

Filesystem agents are the future of computing and knowledge work.

They operate on files and shells—reading, writing, executing. But filesystems weren’t built for agents. They were built for humans in the 1970s.

Mod is a filesystem designed for agents. Version control, branching, querying, collaboration—built from the ground up for how agents actually work.

Filesystem agents are powerful because they work directly on your environment—reading files, writing code, running shells. But the infrastructure they depend on was built for humans, not agents.

The deeper problem: file systems themselves are the bottleneck.

1. Path-based addressing is fragile. Agents need stable references that survive reorganization. Move a file, break every agent that cached the path.
2. Hierarchy assumes single categorization. A file lives in one folder. Agents need the same content accessible by project, type, time, and relevance.
3. No semantic structure. File systems know nothing about content. Agents have to read everything to understand anything.
4. Poor associative retrieval. Agents work best with “find me things related to X” but file systems only support “get me the thing at path Y.”
5. No temporal awareness. What was the state when the agent last worked on this? File systems don’t track this natively.

Teams today use 4+ tools to collaborate. That fragmentation was already painful. With agents, it’s untenable—agents can’t context-switch between systems the way humans do.

Mod is one workspace that replaces the fragmented collaboration stack with agent-native infrastructure.

1. Content-addressed storage. Stable IDs regardless of location. Move, rename, reorganize—the reference stays valid.
2. Graph structures. Relationships are first-class. A document can be part of project X, related to document Y, tagged with concepts A, B, C—all queryable.
3. Embedded metadata. Semantic tags, embeddings, relationship pointers live with the data. The storage layer knows what things mean.
4. Views over collections. Multiple projections of the same content. Chronological, project-based, semantic similarity, agent-defined custom views.
5. Native versioning. Every change tracked. Branch, merge, rollback as primitives. “What did this look like yesterday?” is a simple query.
6. Session/context awareness. Storage knows about agent sessions. “Show me what I was working on” doesn’t require external state.
7. Smart merge. CRDT-powered with full agent context. Fewer false conflicts, faster resolution of real ones.

Three entry points to the platform, all sharing the same data layer.

1. CLI: Replace Git for agent workflows

Point it at any folder. That folder becomes a workspace—branchable, queryable, shareable—without leaving your filesystem. Run multiple agents in parallel, each on their own branch, in the same directory.

2. Workspace: Replace Notion + Linear + GitHub

A collaborative workspace that understands your data. Real-time editing, structured queries, agent-assisted workflows. Your team sees everything agents are doing, comments before code is written, reviews with full context.

3. SDK: Infrastructure for agent builders

Storage, auth, sync, collaboration—all in a single SDK. Use it to power agent sandboxes, collaborative apps built by AI, or local developer tooling.

We’re positioned at the intersection of two massive markets: collaboration tools and AI infrastructure.

The Consolidation Opportunity

Teams pay for Git hosting ($200/user/year), project management ($120/user/year), documentation ($100/user/year), and code review tools ($150/user/year). That’s $570/user/year across fragmented tools that don’t talk to each other.

With agents, the fragmentation tax becomes unbearable. Agents can’t context-switch between systems. Every handoff loses information. Mod consolidates the stack.

The Infrastructure Opportunity

AI inference spend is projected to reach $500B+ annually by 2028. A significant portion will be agents operating on filesystems: writing code, editing documents, processing data. We capture value at the infrastructure layer where this work happens.

Picks and Shovels

Every agent company (Cursor, Devin, Claude Code, custom enterprise agents) is building bespoke solutions for context retrieval, session state, multi-agent coordination, and versioning. They’re all solving the same underlying problem differently and badly. That’s the infrastructure opportunity.

The shift to filesystem agents is happening faster than anyone expected.

1. Explosion of capable agents. Claude Code, Codex CLI, Goose, Aider, Cline, OpenCode—a new filesystem agent launches every week. These aren’t experiments. Millions of developers use them daily.
2. Agents are becoming the default. Junior developers learn with agents. Senior developers delegate to agents. The question isn’t “will you use agents” but “how many are you running?”
3. Multi-agent is already here. Teams run multiple agents in parallel on the same codebase. Git wasn’t built for this. Neither was anything else.
4. Incumbents can’t adapt. GitHub, Notion, Linear are bolting on AI features. But they can’t rebuild their data layers. The architecture is wrong.
5. Infrastructure is the bottleneck. The models are good enough. What’s missing is the layer that lets agents collaborate—with each other and with humans.

Two segments, both usage-based

End users (teams). Replace collaboration stack. Tiered subscriptions with usage-based pricing for agent compute. Free tier to start, paid tiers scale with team size and agent usage.

Developers (agent builders). Infrastructure pricing. Companies building on Mod pay for storage, sync operations, branch operations, inference. Pricing scales with their products.

Lock-in dynamics

Once agents depend on our data layer, switching costs are enormous. Every agent workflow, every piece of accumulated context, every integration—locked in. This is the database/Snowflake playbook applied to agent infrastructure.

1. Data layer lock-in. Once you’re the collaboration layer, you control where agent work happens, how it’s versioned, the substrate everything runs on.
2. Network effects. More users means more shared workspaces. More developers means more tools built on the platform. The ecosystem compounds.
3. Technical moat. We’re building novel primitives: CRDT-based versioning for agent workflows, semantic storage, session-aware branching. This isn’t a wrapper.
4. Ecosystem position. Agent builders integrate us. Their products depend on our infrastructure. We become the standard data layer.