Server data from the Official MCP Registry
Hosted shared memory for AI apps: project decisions, to-dos and learnings. Beta.
About
Hosted shared memory for AI apps: project decisions, to-dos and learnings. Beta.
Remote endpoints: streamable-http: https://hosted.flowstatemcp.com/mcp
Security Report
Valid MCP server (3 strong, 0 medium validity signals). 1 known CVE in dependencies Imported from the Official MCP Registry.
16 tools verified · Open access · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Found in Source Code
Found by scanning the linked source code. This listing connects to a hosted endpoint, so none of this runs on your machine: it describes what the server software does where it is hosted.
How to Connect
Remote Plugin
No local installation needed. Your AI client connects to the remote endpoint directly.
Add this to your MCP configuration to connect:
{
"mcpServers": {
"io-github-dialectforge-flowstate-hosted": {
"url": "https://hosted.flowstatemcp.com/mcp"
}
}
}Documentation
View on GitHubFrom the project's GitHub README.
FlowState
A shared project memory for your AI apps. Free, open source, and stored on your own machine.
Don't want to run a server? Try FlowState Hosted. The same shared memory, hosted for you at flowstatemcp.com/hosted. Add one URL (
https://hosted.flowstatemcp.com/mcp) to Claude, ChatGPT, Cursor or VS Code and sign in. No install, no Python, no tunnel. Your data is encrypted at rest and backed up, and you can export or erase it any time. Beta: 6 months free, then $6/mo for beta members ($12/mo regular). No card needed to start. 10 beta spots.Prefer to keep everything on your own machine? Keep reading: local FlowState is free and MIT forever.
FlowState is a local MCP server. It gives every AI app you use the same memory of your projects: todos, changes, decisions, problems and lessons learned. Your AI reads a short brief when it starts work on a project and writes down what happens as it goes. The next chat (or the next app) picks up where the last one stopped.
Everything lives in one SQLite file on your computer. Your memory is not sent anywhere unless you
turn on an optional feature that does so (an off-site backup to your own private GitHub repo,
remote access through your own Cloudflare Tunnel, or the optional relay). FlowState itself makes
one network call: once a day it asks GitHub whether a newer release is out. It sends nothing
about you or your projects, and flowstate update check off turns it off (see "Upgrading").
If FlowState saves you some re-explaining, a star on GitHub helps others find it.
Many AIs, one memory, at the same time
Claude, ChatGPT, Cursor and Grok can all use FlowState at once, on your computer, across your network, or from your phone (through the optional relay or your own tunnel). When one AI logs a decision or a change, the others see it the next time they check. Hard rules and handoff notes reach every AI, and every change records which AI made it, so you always know who did what. Work across projects is linked too, so a change to something shared shows up in every project that uses it.
Several agents at once
When two agents start on the same project at the same time, both can see the same "next" todo
and quietly do the same work. So an agent claims a todo before it starts
(manage_todos(action="claim", todo_id=4), 15 minutes by default, up to 120) and releases it, or
hands it off with a note, when it stops. Other agents see the claim in their brief
(#4 Fix login (claimed by cursor on mac-mini, expires in 9m)), next skips it and lists it
at the end, and a second claim is refused with the holder's name. Nothing is hidden or locked:
a claim simply runs out if the agent goes away, and it is released when that app's session
ends (quit, ended or idle; the same app reconnecting may take its claim back). Anyone (you included) can still update or
finish a claimed todo; they just get a warning, and manage_history(action="who") shows it.
A decision that reads like a current one (and doesn't say it replaces it) is still saved, but
flagged as a possible conflict (D31 vs D12 in the brief) for the agent and then you to settle
in the review queue; FlowState matches words (and meaning, if the local model is installed), it doesn't judge.
While such a pair is open, the brief's "Recent decisions" keeps the newer one, tagged
(unsettled: may conflict with #12), and leaves the older one's text out, so an AI skimming
the list doesn't follow it as settled. In its place (or on the newer line, if the older one is
too old for the list) is a short pointer, #12 in dispute with #31, text left out: search(query="D12"), which shows the full text in one step. Once you keep both, dismiss it, or
one replaces the other, the brief looks as before.
When two entries clearly disagree, FlowState also queues a disagreement card: claim A and claim B,
who wrote each, and up to two short evidence snippets. You keep the older, the newer, or both, or
dismiss the card. The one you don't keep is marked superseded, not deleted. An agent flags a pair
with log_work (conflicts_with, topic, evidence) or manage_links(action="flag_conflict").
The review page shows the card (side by side on a wide screen), and the tool reply includes the
same card as plain text plus the review link. Chat apps that support MCP Apps can show the card
in the chat (apps on your card list: Claude Desktop to start with; claude.ai or another app that signs in through your tunnel or the relay once you add its sign-in's name with flowstate approvals cards add --sign-in); each button
press carries a one-use code only the card gets, so the AI can't press them itself. Everything else
that waits for your OK (session summaries, suggestions, imports, clean-up ideas) gets its own
in-chat review card in those apps too (see "Where to see what's waiting for you").
Each window of an app gets its own session, and the brief opens with one line about what the
others did meanwhile (Since your last visit (Oct 19): Claude Desktop and Grok saved 3 decisions, 5 changes, 2 todos.), and nothing when nothing changed.
When two decisions clash
FlowState doesn't decide which of two decisions is right. It notices when they might clash, shows it to every AI, and leaves the choice to you.
How a clash gets flagged:
- On its own. When an AI logs a decision that reads like a current one (similar words, or
similar meaning if the optional local model is installed) and doesn't say it replaces it, the
decision is still saved and the pair is flagged as a possible conflict, for example
D31 vs D12. This is matching, not judgement, so some flags turn out to be harmless. - By an AI on purpose. An AI that sees two entries disagree can flag them with a short
topic and up to two evidence snippets (
log_workwithconflicts_with, ormanage_links(action="flag_conflict")). That makes a disagreement card: claim A and claim B side by side, who wrote each, and the evidence.
Where it shows:
- The AI's reply. The
log_workanswer says "Possible conflict with D12 ...", so the AI you are working with can mention it right away. A flagged disagreement comes back with the card as plain text and the review link. - The brief. Every AI that opens the project sees
Possible conflicts: D31 vs D12. While a pair is open, the newer decision is tagged as unsettled and the older one's text is left out of "Recent decisions", so no AI follows either one as settled. - The review queue. Each flag waits for you there: on the review page on your computer, in
flowstate reviewin your terminal, and in an AI'smanage_reviewlist. - Your phone. With the relay set up and phone links on, your phone review list shows it too.
- In-chat tap cards. In apps on your card list that draw MCP Apps cards (Claude Desktop to start with), the AI can show the card in the chat and you tap your choice.
Who settles it:
- You pick the winner. For a possible conflict you say whether the two really clash or fit together. For a disagreement card you keep the older one, the newer one, or both, or dismiss the card. The one you don't keep is marked superseded, not deleted.
- An AI can't pick it for you. The buttons on an in-chat card carry a one-use code that
only the card gets, so the AI can't press them. An AI may pass your choice on only when you
said it in that chat, quoting your words, and the app that made a card can't settle it by
quoting the card's own text. Through the relay an AI can't settle anything in the chat
unless you turn that on (
flowstate relay chat-approvals on). The quoting rule is checked by wording, not by cryptography (see "Honest limits"). - What an AI can do: say that its own new decision replaces an older one
(
log_work(..., replaces=12)or a "supersedes" link). That closes the flag, and the brief and the edit history show it. If that is later undone or the link is removed, FlowState asks you whether to reopen the conflicts it had closed.
Who, which model, which machine
Every change FlowState saves (records, edits, review decisions, links, handoffs, hard rules,
todo claims) keeps who made it. You see it in "Who did what" on the review page, on the
disagreement card, and through manage_history(action="who").
- App: the name the app reports about itself, for example "Cursor". When the app signed
in with a per-app key, a remote token or an approved sign-in through your tunnel or the
relay, the sign-in's name is shown beside it if it differs:
Grok Bot (via work-key). The app chooses the first name; it can't choose the second. A desktop app that starts FlowState itself, or one on the shared LAN token, has no sign-in of its own, so its name is only what it says. - Model: the AI model, only when the app reports it (the
modelargument, theX-FlowState-Modelheader, orFLOWSTATE_MODELfor a desktop app). FlowState never guesses, so this is often blank. - Machine: where the change came from. On your own computer that is
FLOWSTATE_WORKSPACEor the computer's name (or what the app sends); a per-app key can carry its own workspace; over the network it reads likelan (signed in as ...),relay (signed in as ...)ortunnel (signed in as ...). - How it was identified: per-app key, remote token, OAuth sign-in, shared token or self-reported, so you can tell which names the app chose itself.
This is there so you can find a change and undo it. Most of it is what the app says about itself; only the sign-in's name is something the app can't pick.
Why I built it
I built FlowState v1 in January 2026 as a gift to the vibe coder community, back when context was a serious bottleneck and every new AI chat started from scratch. This week I updated it, because the bottleneck moved. Now most of us work across several AI platforms at once, and keeping context between them is the new problem. FlowState stays free and local.
John Martin, DialectForge
FlowState MCP is not related to other products that share the FlowState name, such as a Markdown prompt framework, an academic research paper, or an image tool.
Quick start
Add the local server
The PyPI package is flowstatemcp. pip install flowstate is a different project, so don't
use that name. You need uv.
Cursor. Cursor asks before it saves the server (install links).
If this page will not open a cursor:// link, use the same install on the web:
cursor.com/link/mcp/install.
VS Code. VS Code opens the server so you can review it before you install (install URL).
Claude Code (MCP):
claude mcp add --scope user --transport stdio flowstate -- uvx flowstatemcp
Or start the server yourself with uvx flowstatemcp. pipx run flowstatemcp does the same.
After pip install flowstatemcp, both flowstatemcp and flowstate start it.
Want it on all your devices without running anything? Try FlowState Hosted.
Git clone (backups, the skill, and written app configs)
The clone is the fallback. Use it when you want setup_flowstate.py to create the venv, write
each app's config, schedule backups, and install the skill. Paste this into an AI app that can
run commands on your computer (Claude Code, Cursor, Windsurf, Codex CLI, Grok Build, ...):
Set up FlowState for me from https://github.com/dialectforge/FlowState by following its AGENTS.md.
The AI reads AGENTS.md, asks you which apps to connect and whether you want
nightly backups and the FlowState skill, shows you a dry run, then runs setup_flowstate.py.
When it's done, fully quit and reopen the apps it connected.
Claude Desktop's chat can't run commands by itself. Set it up from one of the apps above ("...and connect it to Claude Desktop"), or run the script yourself (below).
What setup_flowstate.py does
It uses the Python standard library only, and it's safe to run again (it reports unchanged
for anything already set up). In order, it:
- checks for Python 3.11 or newer;
- creates
.venvin the repo folder and runspip install -e mcp-serverinto it (skip with--skip-install); - creates the database if there isn't one, or keeps your existing one and adds only the new FlowState tables and columns (numbered migrations, with an integrity-checked backup first when the database already has data);
- adds a
flowstateentry to each chosen app's MCP config, after saving a copy of that file as<file>.flowstate-backup-<time>. Other servers and settings are left alone; a file it can't parse is refused and left untouched; - with
--offsite-github OWNER/NAME, checks that the GitHub repo is private and saves it for nightly off-site backups (--no-offsiteskips the question); - with
--schedule-backups, adds a nightly local backup to your OS scheduler (Windows Task Scheduler, macOS launchd, Linux systemd user timer or cron), at 02:30 unless you pass--backup-time HH:MM; - with
--install-skill, installs the FlowState skill (see below;--no-skillskips the question); - puts a "FlowState review" shortcut on your desktop that opens the review page
(
flowstate review-page, this computer only). It never replaces a file of that name it didn't make; - with
--verify, starts the server the way your app will and callsstart_hereto check it answers.
At the end it tells you about the daily update check and how to turn it off.
Useful flags: --dry-run (show what would change, change nothing), --help,
--clients auto|all|none|<list> (claude-desktop, cursor, windsurf, claude-code,
codex, grok; auto = every app whose config folder exists), --config <file> (any other
JSON config with an mcpServers object), --db <file>, --python <path>.
Manual install
Needs Python 3.11+. The usual install is uvx flowstatemcp (above). pip install flowstate
does not install this project.
The rest of this section is the git clone, for setup_flowstate.py, backups, and the skill.
git clone https://github.com/dialectforge/FlowState.git FlowState
cd FlowState
python -m venv .venv
# Windows: .venv\Scripts\python macOS/Linux: .venv/bin/python
.venv/bin/python -m pip install -e mcp-server # just the server
.venv/bin/python -m pip install -e "mcp-server[dev]" # plus test tools (pytest)
python setup_flowstate.py --clients claude-desktop --schedule-backups --no-offsite --install-skill --dry-run
python setup_flowstate.py --clients claude-desktop --schedule-backups --no-offsite --install-skill --verify
.venv/bin/python -m pytest tests -q # run the tests
setup_flowstate.py installs into .venv itself, so the pip install lines are only needed
if you want the test tools or manage the venv yourself (then add --skip-install). For the exact,
hash-checked test set CI uses: pip install --require-hashes -r requirements-dev.lock, then
pip install --no-deps -e mcp-server. A plain,
non-editable pip install ./mcp-server (or of a built wheel; on PyPI the name is
flowstatemcp) works too from 2.4.1 on; in 2.4.0 it
left out the database schema, so every FlowState call failed, and the failed start left an empty
database file behind. 2.4.1 sets up such an empty file as a new database, so reinstalling is
enough. flowstate update needs the git clone set up by setup_flowstate.py. Config
snippets for every app, if you'd rather edit configs by hand, are in AGENTS.md.
Questions, or just saying hi
If you are using FlowState and want setup help, or just want to say you are here, email hello@flowstatemcp.com or post in Discussions. Local FlowState does not send us usage data or anything about your projects. The only automatic network call is a daily check of GitHub's public releases, which you can turn off. Don't want to install or keep a computer on? FlowState Hosted is the no-install option.
Guides and tools
Short public pages on flowstatemcp.com. The tools are free, need no sign-up, and run in the browser. Nothing you type there is sent to a server.
Tools
Guides
- How to give Claude Code memory between sessions
- One memory for Claude, ChatGPT, Cursor and Grok
- What is an MCP server?
Comparisons
- FlowState compared: Mem0, the official MCP memory server, and Basic Memory. Each page uses what that project publishes about itself.
What you can ask FlowState
You don't need commands. Talk to your AI app in plain words, and it uses FlowState for you:
- "What was I working on in Atlas?"
- "Save a decision: we're using Postgres, not SQLite, because of multiple users."
- "What should I do next in Atlas?"
- "What did we decide about the database?"
- "What's waiting for me in FlowState?"
The full list, with what each request does, is in docs/WHAT-TO-ASK.md.
The FlowState skill
skills/flowstate is an Agent Skill: a short set of habits (read
the brief first, log to the right project, link shared components, never approve your own review
items, leave a handoff if you stop mid-task). Apps that load skills follow it without being told.
- With setup:
python setup_flowstate.py --install-skill(or answer "yes" when it asks) copies the folder to~/.agents/skills/flowstateand~/.claude/skills/flowstate. An older, different copy is moved to~/.agents/flowstate-skill-backups/or~/.claude/flowstate-skill-backups/first. - By hand: copy the
skills/flowstatefolder into~/.agents/skills/or~/.claude/skills/. - Claude apps and ChatGPT: zip the
skills/flowstatefolder yourself and upload the ZIP in the app's Skills settings. (FlowState doesn't build the ZIP for you.)
No skill support in your app? Paste the three lines in Make your AI use FlowState.
The server also sends these rules to every app when it connects, and offers them as the MCP
prompt flowstate-start.
Make your AI use FlowState
FlowState only helps if the AI reads it at the start and writes as it goes. The server already says so when an app connects. Paste the same three lines into the app's own rules so it keeps doing it:
Call start_here at the start of a conversation about a project.
Call log_work right after each decision, change, fix or lesson.
Call log_work again before you end the session or hand back.
CLAUDE.md and Claude Code. Plain markdown, no front matter. Put it in CLAUDE.md or
.claude/CLAUDE.md in the project, or in ~/.claude/CLAUDE.md for every project.
How Claude remembers your project.
AGENTS.md and Codex. Plain markdown. Put it in AGENTS.md in the project, or in
~/.codex/AGENTS.md for every repository.
Custom instructions with AGENTS.md.
Cursor. Save this as .cursor/rules/flowstate.mdc. alwaysApply: true puts it in every
chat. A plain .md file in that folder is ignored.
Rules.
---
description: Keep FlowState project memory up to date
alwaysApply: true
---
Call start_here at the start of a conversation about a project.
Call log_work right after each decision, change, fix or lesson.
Call log_work again before you end the session or hand back.
Windsurf. Save this as .windsurf/rules/flowstate.md. trigger: always_on includes the
whole file in every message. The same front matter works in .devin/rules/ if that is the
folder your build uses. Current docs still import .windsurf/rules.
Memories and rules.
---
trigger: always_on
---
Call start_here at the start of a conversation about a project.
Call log_work right after each decision, change, fix or lesson.
Call log_work again before you end the session or hand back.
VS Code Copilot. Plain markdown in .github/copilot-instructions.md. Copilot adds that
file to chat requests in the repository.
Custom instructions in VS Code
and GitHub Copilot custom instructions.
Claude Projects and claude.ai. Open the project, choose Set project instructions, and paste the three lines. They apply to every chat in that project. How to create and manage projects.
ChatGPT. Settings, Personalization, Custom instructions (on a phone: Settings, Customize ChatGPT). Turn customization on and paste the three lines. They apply to your chats. ChatGPT custom instructions.
Features
Memory your AI actually reads
start_herebrief: one call gives the AI the project's hard rules, handoff notes, open todos, problems, recent changes, decisions and key lessons. Sizes:quick(about 1,500 characters),standard(4,000, the default) ordeep(up to 12,000).log_work: one simple tool to record a decision, change, problem, learning or todo. Every write must name a project, so nothing lands in the wrong place.- Write receipts: every write's answer says what it saved (
receipt: {change: "3f9a1d2c4b5e", saved: ["decision #31"]}). A write that timed out but saved a moment later is reported on the next answer, and the same write repeated within 2 minutes returns the first receipt instead of saving a copy. - Automatic sessions: a session opens on the first call for a project (one per app window
or connection) and closes after 2 hours idle (or when the app quits), with a short summary
marked
[auto-captured, needs review]. A small housekeeping session (only reads, undo, review decisions, a handoff pickup or todo claims) isn't queued for review. FlowState keeps a lean record of each session's reads and writes (record ids and hashes, never the text).
You stay in charge
- Review queue: auto-captured summaries, and anything the AI marks as a suggestion, wait
for your OK. Approve, edit or reject them in chat, on the review page, or with
flowstate approve <id>in your terminal. The app that queued an item needs your own words to decide it. An AI that reaches FlowState through the relay can't approve or reject anything in the chat: it tells you to decide it yourself instead (see "Chat approvals through the relay" below). - Review mode (yours to set):
off,auto_only(default), chosen record types, oreverything. Set it for the whole install or per project. The AI may change it only when you ask in the chat, and every change is logged with your words. With approvals on, turning review off also waits for your own click or key. - Hard rules: "never do this" rules per project, always shown in full at the top of the brief.
Only you set or remove them: when an AI asks to add or remove one, that waits in the review
queue for your own click or key (review page, phone or
flowstate approve <id>);flowstate rules add/flowstate rules remove <id>in your terminal do it at once. - Handoff notes: an AI that has to stop mid-task leaves "where I was / next step"; the next AI sees it first until it picks it up.
- Undo and history: edits made through FlowState are kept; you can see them and undo the last change to a record (an undo can itself be undone). The app that created a record can take it back with undo while nothing refers to it yet. If part of a change was changed again since, undo puts back the rest and lists what it skipped and why.
- Deletes you can always take back: out of the box FlowState never interrupts you. When an AI deletes a project, a component or a record, FlowState first takes a safety copy and keeps every removed row (children and links too) in the edit history, so undo brings all of it back exactly. The answer and the brief say in one line what went and how to undo it.
- Approvals, if you want them (
flowstate approvals on; off by default, also after an upgrade): then an AI's delete, and turning review off, wait for you, and no app can pass your OK along. You decide in the app's own popup (Claude Code, Cursor, VS Code, when they connect directly and not through the relay or the internet), on your phone (only if you use the optional FlowStateMCP hosted relay: you sign in at flowstatemcp.com, your phone talks to your own FlowState, and the site never sees the item), or withflowstate approve <id>in your terminal. Every decision is logged with how it was made. With approvals off, an AI can delete without asking you; the safety copy and undo are what protect you then. - Chat approvals through the relay: phone only, unless you allow them
(
flowstate relay chat-approvals on|off; off by default). An AI connected through the optional relay (claude.ai, ChatGPT and other cloud AIs) can't approve or reject review items in the chat, even when you tell it to there: its answer says nothing was decided and tells you to decide it yourself on your phone, from the review link you saved (or on the computer where FlowState runs). It doesn't give the phone link itself: that contains your relay handle, and cloud chats are stored by the AI company. Turn it on in a terminal on that computer (it asks you to typey) and those AIs can approve and reject again when they quote your words, as before. Either way, the items that are yours alone stay yours alone: deletes and turning review off while approvals are on, and "did you say this yourself?" checks. Apps that connect directly (on this computer or your own network) are not affected. There is no tool for this setting, so an AI can't switch it on through FlowState. - Superseded decisions: a new decision can name the one it replaces, so only the current one shows in the brief.
- Source and last-verified flags: records can say where they came from (
user_stated,ai_inferred,from_code), and FlowState stores who set that tag and when (the app, the model if the app gave it, or "user" when you confirmed it). Facts like paths, ports and config not checked for 60 days are listed for re-checking. - Only you turn a guess into "you said so": an app may tag what it writes as
user_statedwhen it quotes you, and the brief then says(user, via <app>): that is the app's claim. Once you confirm it yourself it says(user, confirmed by the user), andsearchandmanage_historyshow who set the tag and when. Changing an existing record touser_statedis yours alone, approvals on or off: the app's request leaves the tag as it is and queues one review item, which you confirm on the review page, on your phone or withflowstate approve <id>; no popup, review walk box or in-chat card offers it. No app can confirm it for you. Auser_statedwrite that repeats another app'sai_inferredrecord is saved asai_inferred. What this doesn't cover: FlowState can't check that an app quoting you at log time is telling the truth; the tag then names that app.
Accountability
- Who, model and machine on every change: edit history, review queue items and decisions, links, handoffs, hard rules, review-mode changes and the activity log all record which app made the change, the AI model (only when the app supplies it; never guessed), the machine or workspace, and how the app was identified (per-app key, remote token, OAuth app, shared token or self-reported).
- "Who did what" view: on the review page, filter by app, model, machine, project and time
(50 per page) and undo a change from there (the normal undo, with the page's CSRF and origin
checks). AIs can read the same list with
manage_history(action="who"). - Per-app keys for the local/LAN HTTP server:
flowstate keys add --name "<app>"gives each app its own key (optionally read-only). FlowState records the name the app sends and the key's name beside it, which the app can't change ("Grok Bot (via my-laptop-key)" when they differ, one name when they match). The key is shown once and only a hash is kept; a revoked key is refused (401) at once. Keys aren't accepted on the public listener, and can't usemanage_data_gitor attach files. The old shared LAN token still works; its changes are marked "shared token (legacy)".
Projects that share things
- Cross-project links with change alerts: when several projects use one thing (for example, "Atlas VPN uses the Wire Protocol component of Atlas OS"), link them. A change logged on the shared component gives every linked project an update todo and a "changed since you last looked" note. FlowState alerts; it never changes code in other projects.
- GitHub and Linear links: attach an issue or PR URL to a todo, problem or other record.
Tasks
- Priorities: critical, urgent, normal, low (the older names high and medium still work).
- Subtasks, blockers and "what's next":
todo(action="next")lists open, unblocked work, highest priority first.
Finding things
- Ask a question:
search(query=..., answer=true)takes a question in plain words; FlowState answers by quoting your own records, with their ids, and says so when it has nothing on it. It doesn't make anything up. - Search: keyword search over todos, decisions, changes, learnings, problems and solutions (word endings match too). Search by meaning is optional and uses a local model you install yourself.
- Clean-up suggestions: duplicate and stale todos, and records filed under the wrong
project, sent to the review queue as one plain question each (
Move learning "..." from A to B? It mentions B.). It only suggests a move when the record names the other project or one of its parts, never a guess it isn't sure of. Unsure move ideas left over from older versions are withdrawn (no record moves). Nothing moves until you approve.
Your controls (command line and browser)
- Local review page: a small page in your browser, on this computer only: review queue,
review mode, pause apps, "Who did what", Project history. Click the link in your AI's answer (see "Where to see
what's waiting for you"), double-click the "FlowState review" shortcut setup puts on your
desktop, or run
flowstate review-page(one-time link). The page an AI's link opens can pause an app but never resume one (flowstate apps resume, or the pageflowstate review-pageopens). - Per-app activity log and pause: see which app did what (
flowstate apps list/apps activity) and pause one app's writes (apps pause --app NAME). A paused app can still read. - Markdown export and import:
export-mdwrites a readable copy of a project;import-mdbrings your edits back through the review queue. - Memory import: bring a Claude or ChatGPT memory export (text, markdown or JSON) into the
review queue (
import-memory, or theimport_memorytool). - Opt-in git capture: off by default. Turn it on per project and new commit subjects become changes (subject lines only; no author, e-mail or diff).
Safety and backups
- Secret refusal: a write that looks like it contains a key, token, password, private key
or card number is refused (
secret_detected) and not saved.flowstate scan-secretslists older records that look suspicious, without showing values. - Token in the OS credential store: the HTTP bearer token goes in Windows Credential
Manager, the macOS Keychain, or on Linux a
~/.config/flowstate/http-tokenfile with mode 0600. - Nightly backups: integrity-checked; the newest per day for 14 days and per week for
8 weeks are kept. Restore always goes to a new file unless you add
--force(and then the current file is backed up first). - Safety copies: right before a delete, an approved clean-up or markdown edit, before a
restore or a migration, and before data-git brings in another computer's changes or runs
data-git migrate, FlowState takes a verified copy that is kept at least 7 days whatever the limits above say; if it can't, the change isn't made. This doesn't depend on nightly backups, and FlowState never adds a daily copy you didn't ask for. - Health check: on start, a quick check of the database. Only a problem shows, first in the brief, with the newest good backup. FlowState never repairs anything by itself.
- Optional private GitHub off-site copy: opt-in. FlowState checks the repo is private
before every push and refuses otherwise. It pushes only the encrypted backup file and a small
unencrypted note with its date, size and checksum, to its own branch, using your existing
ghor git login. It never stores a GitHub token.
Connecting
- stdio and HTTP transports: stdio for apps on the same computer; streamable HTTP with a
bearer token for other machines on your network, or a separate key per app
(
flowstate keys add). - Optional remote access: for cloud AIs (claude.ai, ChatGPT and others), a public listener
behind your own Cloudflare Tunnel with OAuth 2.1 sign-in that you approve with an owner
passphrase, plus revocable per-app tokens (optionally read-only; use one token per app,
flowstate remote clientslists them,flowstate remote rename OLD NEWrenames one without making a new token). See docs/REMOTE-ACCESS.md. - Fewer or more tools: 12 tools are listed by default.
--tools core(orFLOWSTATE_TOOLS=core) lists only the 6 everyday ones to save context;--tools fulladds the 6 specialist ones. The default tools answer in every profile; the specialist ones only infull(called by name elsewhere, they are refused:not_in_profile). Every tool is labelled read-only or read-write (per action in its_meta).
Works with
- Claude Desktop, Claude Code, Cursor, Windsurf, Codex CLI, Grok Build:
local stdio, set up by
setup_flowstate.py. - claude.ai and ChatGPT: through the optional remote access (HTTPS + OAuth), see docs/REMOTE-ACCESS.md.
- Any other MCP client: stdio (
<venv python> -m flowstate) or HTTP with a bearer token. - Any of these, with no install: through FlowState Hosted.
Why FlowState
Many AI memory tools now put their best features behind subscriptions: Zep ($125/mo and up), Supermemory ($19/mo and up). Mem0 no longer sells Starter, Growth or Pro to new accounts (people already on those plans keep their old prices; see the pricing FAQ). New accounts get Free, or Custom, which is sales-led and has no published price. On Free, Mem0 pays the model calls for the first 30 days (10,000 adds and 1,000 retrievals a month). After that you connect your own LLM key (you can connect one during the first 30 days too) for 50,000 adds and 10,000 retrievals a month at no charge from Mem0. Past those limits you can turn on usage-based billing, with a monthly cap you set. Some have dropped their free or self-hosted options entirely, like Zep's self-hosted edition and Pieces' free tier. FlowState is MIT-licensed and runs on your own machine. Local FlowState is free and MIT forever. An optional paid hosted version and relay are at flowstatemcp.com; paid plans charge for hosting, never for features.
Prices as listed on each vendor's pricing page, November 2026.
Add your own features
FlowState is open source and built to be worked on by AI: AGENTS.md and llms.txt explain the repo, the code is split into small modules, and there's a test suite that runs against temporary databases. If you think of a feature, have your AI build it. You're not waiting on a vendor's roadmap.
The v1.1 desktop GUI was an unfinished experiment and has been removed. v2 is used through your AI and the browser review page.
Where to see what's waiting for you
Some things wait for your OK: session summaries FlowState wrote on its own, records an AI suggested, clean-up ideas, "did you say this yourself?" checks, and (with approvals on) an AI's deletes. You don't need a terminal to see and decide them. Nothing pops up unless you ask, or you have turned approvals on.
Documentation truncated — see the full README on GitHub.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
mcp-creator-python
Freeby mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.


