FUSE filesystem interface

Your agent runtime shouldn’t hide inside a database.

CortexFS mounts models, agents, tools, and durable sessions at /ctx — a small Unix ABI you can ls, cat, execute, secure, and audit.

Watch the introduction Install CortexFS GitHub

017 stable root names02FUSE mounted03policy-bound04durable JSONL

Stable root ABI$ ls /ctx

statusbinmodelagenttoolhomeshared

modelA model is a pure inference file: read metadata, execute one inference.

Project introduction

Meet CortexFS.

An overview of the stable /ctx ABI, its model, agent, and tool objects, and durable sessions.

Running product, not a diagram

Watch the runtime while it works.

The real CortexFS CLI talking to a coder agent; commands, tool calls, and session paths remain directly visible.

Three executable objects, one durable history

The important parts of the runtime stay directly operable.

CortexFS exposes three executable object classes and keeps session history in ordinary files, letting shells and permissions do the jobs they already understand.

01model

Models are pure inference files

Read the file for metadata; execute it for one-shot inference. Provider connections and API formats stay behind the unified model ABI.

/ctx/model/main → gpt-5.6-sol · kimi-k3

02agent

Agents orchestrate under policy

An agent is exposed as an executable object and socket. Its Linux identity, mounts, cwd, model, and policy bound what it can see and run.

/ctx/agent/coder  +  coder.sock

03tool

Tools are executable capability endpoints

Agents invoke tools through tsh. tsh resolves capabilities only through CTX_PATH and never falls back to the host PATH.

CTX_PATH=/ctx/tool:/ctx/home/<uid>/tool

04session

Sessions preserve raw history

messages.jsonl and events.jsonl remain durable and append-only; prompt context is a disposable, rebuildable working set.

session/default/{messages,events}.jsonl

Inspectable authority

Linux permissions and runtime policy meet at the path.

mount ∩ uid/gid/mode ∩ policy ∩ CTX_PATH ∩ noexec

Visibility is not a promise in a prompt. Mounts, uid/gid/mode bits, CortexFS policy, CTX_PATH, and noexec combine into the authority an agent actually receives.

Provider-neutral by design

One stable ABI above changing APIs.

one ABI / changing APIs

CortexFS owns paths, object lifecycle, permissions, and session semantics. Rig owns provider connections and API event adaptation. Provider details never expand into new root directories.

Seemount ∩ uid/gid/mode

ResolveCTX_PATH

Executepolicy ∩ noexec

Effective authority = the intersection of every boundaryroot contains stable object classes only

Quick start

From package to a live chat in three steps.

These are the install, mount, and interaction commands from the current README.

Read the full installation guide →

01
Install
Install CortexFS from the AUR.
```
paru -S cortexfs-git
```
02
Mount and verify
Start the systemd FUSE mount, then inspect effective health.
```
sudo systemctl enable --now cortexfs.service
ctx doctor
```
03
Bootstrap and chat
Materialize the defaults, start coder, and enter the preferred human chat UI.
```
ctx bootstrap
ctx agent start coder
ctx agent chat coder
```

Bring the runtime back to Unix

Small enough to audit. Useful enough to build on.

Read the specification for the stable boundary, inspect the implementation on GitHub, or mount /ctx and start using it.

Read the specification GitHub Install CortexFS