Docs

On this page

What esfis is

esfis is a macOS app for working on your projects with the AI agents you already use. It is not a platform you have to move anything into: it runs on top of the folders, files and sessions that are already on your computer.

It has three parts:

Projects

Your folders. Each one has its own activity, its own tasks and its own context space.

Agents

The CLIs you already know — Claude Code, Codex, Copilot, Grok, Antigravity, Ollama — in real terminals.

Context

What the project has to remember, shared with every agent over MCP and stored on your Mac.

The window has four sections: Home (projects and activity), Agents (the terminals), Memory (the context) and Settings. The app, the esfis command line and the MCP server are all the same binary.

The first five minutes

1. Add a folderIn Home, “Add a folder”. It becomes a project and gets its space.
2. Open an agentIn Agents, pick one. It opens in the folder, with your PATH and your keys.
3. Connect the contextIn Settings, copy the command for your agent and hit Check.
4. Come back tomorrowHome tells you where you left off and what each agent decided.

The command for Claude Code, which is the one most people need:

Copyclaude mcp add --scope user esfis -- ~/.esfis/bin/esfis --mcp

Projects

A project is a folder. You add it from the app, and esfis neither moves it nor rearranges it. Everything that happens there — the agents you open, their sessions, the context they store — is tied to that folder.

Every project, its own space

Adding the folder creates a space with its name and its path. An agent working inside it is already in the project: nobody has to tell it anything. If a space already contains that folder (a client space grouping several projects, say) or one already has that name, esfis leaves it alone; it only attaches the folder if the space had none.

From the terminal it is the same thing:

Copyesfis --space-add project1 --path ~/Documents/Project1

Agents

Each agent is the CLI you already use, in a real terminal inside esfis. It opens in the project folder with a login shell — the same PATH and the same keys as your own terminal — and talks to its provider exactly as it would outside esfis.

Several at once

Split the window (⌘D to the right, ⇧⌘D below), send the same prompt to every session (⇧⌘B), and switch projects without stopping the agents in the others.

Models, sessions and providers

• Every pane has its own model menu, which switches the model using that CLI's own command (/model, or /load in Ollama) without closing the session.
• Changing section or closing the window stops no agent. Quitting esfis does, and it asks first.
• Providers you do not use can be switched off in Settings › Agents.

Tasks

Next to each agent sits the project's Tasks panel, for noting what should not happen right now without losing your thread.

Every task remembers which agent you sent it to. The list is a Markdown file inside the project, at .esfis/feina.md, with one - [ ] line per task: you can edit it by hand, and it travels to any Mac that has the folder.

Activity

Home has one row per project, from the one you touched most recently to the one you have left alone longest. It is there so you can get back to work without having to remember where you were.

Files and last change

from the folder

Branch

.git/HEAD

Open agents

right now

Context and decisions

from the space

Sessions and agents

last 30 days

Open tasks

.esfis/feina.md

Latest decision and where you left off

context + sessions

All of it is read from disk, in the background and without spawning subprocesses, from the logs Claude Code, Codex and Grok already leave behind. Folders like node_modules or .build are not counted.

Context

A project's context is made of short items: decisions, instructions, goals, people, technologies. Each one remembers where it came from and when it was stored, and a new one can supersede an old one instead of sitting next to it.

Who sees it

A project's context only reaches the agents working on that project. Personal context — which language you want answers in, say — reaches everywhere.

How agents get to it

They read and write it over MCP. What is worth storing is decided by the agent; esfis only stores and retrieves, with no model call of its own. Every item carries the agent that stored it as its source, and the agent that receives it the next day can see that: “The API runs on PostgreSQL · Claude Code”. How to connect each agent is in Connecting your AI.

Types

identity, preference, person, project, goal, decision, technology, event, knowledge and instruction. Every item also records who stored it and whether it was stated outright or inferred, and it can carry an expiry date.

Memory

The Memory section shows you all the context and lets you correct it.

List and Text

List is one row per item, with its type, where it came from and the buttons to change its type or forget it. Text is the whole context as running text:

Copy## Standing instructions
[#3] Always answer in Catalan.

## Memories
[#12] The project is deployed on Vercel.

• Rewrite a line and you change that item.
• Delete it and it is forgotten: deactivated, and recoverable from the forgotten items.
• Add one without an [#id] and it is new.
• Nothing is stored until you press Save (⌘S), and if an agent wrote something in the meantime, it tells you first.

Test and Conversation

These are two Settings tabs, next to Spaces. Test picks an AI and a space, asks it a question and shows what it would receive, with the score of each item and what stayed out. Conversation extracts context from a conversation you paste in, using the Anthropic API and your own key: it is the only feature that leaves the machine, and with MCP connected you do not need it.

MEMORY.md

~/.esfis/MEMORY.md is the readable copy of your personal context (a space's context is not in there, because every project reads this file). Claude Code can read it without MCP if you add @~/.esfis/MEMORY.md to ~/.claude/CLAUDE.md.

Copyesfis --export            # refresh ~/.esfis/MEMORY.md
esfis --import-document   # take back whatever you edited in it

Bringing in what you already have

The memory .md files assistants leave in ~/.claude/projects/<project>/memory/ can be imported. Running it again duplicates nothing, and an edited file replaces the old version.

Copyesfis --import                       # ~/.claude/projects
esfis --import ~/notes ~/other/mem   # or whichever folders you name

Spaces and policies

Spaces keep each project's or client's context apart. Policies say which AI sees which space. And the trace explains, afterwards, what each AI received and why.

Spaces

An item with no space is personal and goes everywhere. An item with a space only ever surfaces inside it, and the space is checked before anything is searched: a perfect match belonging to another client is never even scored. An agent's space comes from the folder it works in (the longest path containing it); ESFIS_SPACE pins it.

Copyesfis --spaces
esfis --space-add acme --kind client --path ~/Clients/acme
esfis --move 184 acme
esfis --add "Acme pays on 60-day terms." --space acme --until 2026-12-31

Policies

The most specific rule wins: this AI in this space, this AI everywhere, everyone in this space, everyone. With no rule, access is allowed. An agent that cannot see a space cannot write to it or forget anything in it either.

In Settings › Spaces you choose, for every space and every AI, “Has access”, “No” or whatever the general rule says. From the terminal it is the same thing:

Copyesfis --deny chatgpt acme
esfis --deny '*' acme
esfis --allow claude-code acme
esfis --policy

Why it saw what it saw

Every recall over MCP leaves a delivery behind: what went in, what stayed out and why. Identifiers and reasons are stored, not the text. Of what another space or a policy kept out, the items that would have answered the question are named and the rest are counted. Deliveries are also in Settings › Spaces: click one and out comes the explanation.

Copyesfis --deliveries
esfis --why 212
esfis --preview "which datastore do we use" --as codex --space esfis

CLAUDE.md and AGENTS.md

--compile writes the current context inside a marked block (<!-- esfis:begin --> … <!-- esfis:end -->) and touches nothing outside it. Compiling again with no changes does not change a single byte.

• What goes in: instructions, identity, preferences, projects, goals, decisions and technologies.
• Only if they are active, current, stated outright and permitted for that assistant.
• Personal context only with --with-personal, because these files end up in git.

Copyesfis --compile agents --space esfis
esfis --compile claude --print
esfis --import-instructions CLAUDE.md   # the way back

esfis and CLAUDE.md

esfis does not replace CLAUDE.md or Claude Code's Auto Memory: CLAUDE.md can be an output of esfis rather than its source. The difference is where the context lives and who is allowed to read it.

Compared with Claude Code as of September 2026.

Agent usage

The bar at the bottom of the Agents section, and its usage panel, show how much each agent has used, today and over the last few days, and how the machine is doing: CPU, memory and the hungriest processes. It is all read from the logs each CLI already writes locally, with no API calls at all.

Copyesfis --usage --days 14     # the usage panel, as text
esfis --claude-bridge       # Claude's real limits (--remove takes it out)

Costs are an estimate based on public prices, which you can adjust in ~/.config/agent-orchestrator/pricing.json.

Connecting your AI

Settings › Connect your AI has what to copy for each client, and a Check button. esfis never writes another program's configuration for it.

The generic form, for any other MCP client:

Copy{ "mcpServers": { "esfis": { "command": "/Users/<you>/.esfis/bin/esfis", "args": ["--mcp"] } } }

The tools

Terminal commands

Everything the app does can be done from the terminal. esfis --help has them all; they exit 0 on success and 1 on failure.

esfis --doctor runs one check per line: the database, the schema, the vectors, whether the binary is the one the MCP configuration points at, whether MEMORY.md is up to date and whether there are duplicates. The same report is in Settings.

Shortcuts

Local data

Everything is stored on your Mac. The MCP server speaks over standard input and opens no ports, and no account is needed.

To show activity and usage, esfis reads files the CLIs already leave on disk, such as ~/.claude/projects or ~/.codex/sessions, and sends them nowhere.

Supported agents

Any other MCP client can read and write the context too, Cursor and Gemini CLI among them.

In development

esfis is at an early stage. Some features may change or disappear, and these pages are updated when they do. What has shipped is in the changelog.