Agents love files. Lose the limitations.

the filesystem
is the API.

TigerFS turns PostgreSQL into a versioned, transactional filesystem, either the backend for your files or a filesystem over your data. Every change is logged and reversible, so you can roll back when needed.

$curl -fsSL https://install.tigerfs.io | sh
Get started Read the docs
Two modes

the ease of a filesystem, the semantics of a database.

A folder and a database: two views of the same thing
File-first

files with database guarantees

Coordinating agents through local files means no transactions, no history, no structure. Git needs pull, push, and merge. S3 has no transactions.

TigerFS gives you the filesystem interface agents already know, with atomic writes, automatic version history, and one-command undo. Works with Claude Code, grep, vim, and everything that speaks files.

  • transactional + versioned ACID writes and automatic version history on every file, not bare files with no guarantees
  • shared, no merges agents and humans, whether local or distributed, share one state; changes are visible immediately, with no pull, push, or merge
  • atomic undo roll back any change: a single edit, a whole session, or just one agent's work
Explore file-first →
Data-first

treat your data as a filesystem

Reaching into a database usually means a SQL client, a schema you have to remember, and client libraries to pass around. Agents pay that cost on every task.

TigerFS mounts any Postgres database as a directory, with the interface your agents already know mapped directly onto your data. Read rows, filter by index, chain queries into paths.

  • no sql, no client reach your data through plain files; no client libraries or schemas to pass around
  • query pushdown chain filters, ordering, and pagination into one path that runs as a single fast SQL query
  • edit live data review and update rows with vim, cat, diff, and the tools you already use
Explore data-first →
New in 0.7 .log/→.savepoint/→.undo/

Let agents run, then roll back what you don't like: a single edit, everything since a savepoint, or just one agent's work, in one atomic undo. See safe exploration →

How it works
Unix Tools
ls, cat, grep, rm
→
Filesystem
FUSE / NFS
→
TigerFS
Local Daemon
→
PostgreSQL
Database

Filesystem paths map to SQL queries. Writes are transactions. The filesystem becomes the API.

Use cases

what you can build

File-first

a shared agent workspace

Point a whole swarm at one knowledge base. Every write is an atomic transaction and every version is kept, so when two agents touch the same file nothing gets clobbered; you diff against history and recover in a single command.

Explore file-first →
# two agents, one source of truth — no sync, no merge cat > /mnt/kb/auth.md << 'EOF' # OAuth findings... EOF # clobbered? recover the previous version cp /mnt/kb/.history/auth.md/<ts> /mnt/kb/auth.md
File-first

let an agent loose, safely

Drop a savepoint, then let the agent refactor freely. If the tests don't pass, roll back everything it touched — or just one agent's changes — in a single atomic undo. Even the undo is reversible.

See safe exploration →
# bookmark the current state echo '{"description":"pre-refactor"}' \ > /mnt/code/.savepoint/safe.json # ...agent works... tests fail? undo it all touch /mnt/code/.undo/to-savepoint/safe/.apply
Data-first

fix live data in one command

Update a customer's tier, flip a feature flag, delete a test record, with no SQL client and no carefully crafted WHERE clause. Echo a value into a column or PATCH a whole row with JSON. Every path is a transaction.

Explore data-first →
# one column echo 'premium' > /mnt/users/42/tier.txt # or PATCH a whole row (only listed keys change) echo '{"tier":"premium"}' > /mnt/users/42.json
Data-first

query huge tables with grep and awk

Push filters, ordering, and pagination into the database through a single path, then let the tools you already use finish the job. Huge tables stay fast. No exports, no client libraries, no SQL.

Explore data-first →
# filter runs in Postgres; awk sums the result cat /mnt/orders/.filter/status/shipped/.columns/total/.export/csv \ | awk '{s+=$1} END {print s}'
How it compares

one tool, the whole job

Each alternative does part of the job. TigerFS is the only one that does all of it.

Capability TigerFS Local files Git Hosted versioned-FS DB + SQL client
Works with any Unix tool (ls/cat/grep/awk)✓✓✓✓✗
Backed by a real, queryable database✓✗✗✗✓
Distributed agents share state, changes seen instantly✓✗✗✓✓
Version history + atomic undo✓✗✓✓✗
Query pushdown over large data✓✗✗✗✓
Open, free, self-hostable✓✓✓✗✓

up in under 60 seconds.

Available now, open, and free.

Works with any PostgreSQL, with special Tiger Cloud and Ghost support.

FUSE on Linux, NFS on macOS, and no external dependencies on either platform.

Install
curl -fsSL https://install.tigerfs.io | sh
Mount and write
# mount a local database tigerfs mount postgres://localhost/mydb /mnt # or create a new Ghost database tigerfs create ghost:my-project /mnt # start writing (history requires TimescaleDB) echo "markdown,history" > /mnt/.build/workspace echo "# Hello World" > /mnt/workspace/hello.md
Read the quickstart