FUSE filesystem interface

An agent runtime you can inspect with a shell.

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

Install CortexFS Find a guide GitHub

018 stable root names02FUSE mounted03policy-bound04durable JSONL

Stable root ABI$ ls /ctx

statusbinmodelagenttoolchannelhomeshared

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

Quick start

Install. Check. Start working.

Requires Linux, systemd, and FUSE. Check the mount, then configure a provider before opening a session.

Read the full installation guide →

01
Install
The installer checks dependencies and asks before changes. Native Linux packages are also available.
```
curl -fsSL https://raw.githubusercontent.com/LIghtJUNction/cortexfs/main/scripts/install.sh | sh
```
02
Check the runtime
Start the mount and inspect runtime health. Provider credentials are configured separately.
```
sudo systemctl enable --now cortexfs.service
ctx doctor
```
03
Open a work session
After provider setup, run ctx in your project. Use ctx resume to continue this folder’s session later.
```
ctx
# Continue later
ctx resume
```

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.

This recording uses the earlier coder agent. The current default is executor; start an interactive session with ctx.

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 → provider route

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/executor  +  executor.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. Its protocol adapters own 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

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