Lets AI agents manage local tasks, documents, and notes in Markdown to maintain long-term memory and context.
Also known as rgdevment/Tisty, tisty-mcp
- Stars
- 10
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 1.47.1
- Last commit
- Nov 16, 2026
- License
- AGPL-3.0
What is Tisty MCP?
Tisty lets AI agents manage local tasks, documents, and notes in Markdown to maintain long-term memory and context.
Summary generated from the project's README
About Tisty MCP server
Managing long-term context and local documentation for AI agents is what Tisty enables for developers and project managers on Windows and macOS. By providing a local-first workspace for tasks, documents, and notes in Markdown, it allows assistants like Claude Code, Cursor, and GitHub Copilot to maintain a persistent memory that survives individual chat sessions. Instead of rereading massive files, the MCP server allows an agent to read an outline first and then access only the specific sections required, significantly reducing token usage.
Users interact with their data through a native application built with a Rust core and Tauri, ensuring fast performance and local privacy. The system organizes information into subject-specific documents and tasks that include dated journals and step-by-step histories. Because everything is stored as plain Markdown on your own disk, your data remains accessible via standard tools like grep or cat, even without the application. There are no accounts, subscriptions, or telemetry involved in this open source solution.
What you can do with it
- 1Resume interrupted development sessionsAn AI agent can pick up exactly where it left off by reading the specific task and recent journal entries.
- 2Reduce AI context costsThe server allows an assistant to read a document outline and only the necessary sections rather than the entire file.
- 3Retrieve historical problem solutionsDevelopers can ask an agent to find how a specific technical issue was resolved in the past using archived task journals.
Written from the project's README. Every use case is checked against a quote from it.
How to install Tisty MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Tisty MCP in Claude Code
$ claude mcp add tisty -- npx -y tisty-mcpInstall Tisty MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"tisty": {
"command": "npx",
"args": [
"-y",
"tisty-mcp"
]
}
}
}Install Tisty MCP in VS Code
.vscode/mcp.json
{
"servers": {
"tisty": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"tisty-mcp"
]
}
}
}Install Tisty MCP in VS Code CLI
$ code --add-mcp '{"name":"tisty","type":"stdio","command":"npx","args":["-y","tisty-mcp"]}'Install Tisty MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"tisty": {
"command": "npx",
"args": [
"-y",
"tisty-mcp"
]
}
}
}Install Tisty MCP in Codex
$ codex mcp add tisty -- npx -y tisty-mcpInstall Tisty MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.tisty] command = "npx" args = ["-y", "tisty-mcp"]
Install Tisty MCP in Gemini CLI
$ gemini mcp add -s user tisty npx -- -y tisty-mcpInstall Tisty MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"tisty": {
"command": "npx",
"args": [
"-y",
"tisty-mcp"
]
}
}
}Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work · What to fix for more points
- Source repository linked and reachablergdevment/tisty is public and reachablegithub.com/rgdevment/tisty ↗Pass
- Package names this repository as its sourcetisty-mcp names git+https://github.com/rgdevment/mcp-plugins.git as its sourcenpmjs.com/package/tisty-mcp ↗Finding
- Build provenance (Sigstore attestation)Sigstore attestation for tisty-mcpnpmjs.com/package/tisty-mcp/v/1.3.1#provenance ↗Pass
- Open source license (OSI)AGPL-3.0spdx.org/licenses/AGPL-3.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-13github.com/rgdevment/tisty ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from tisty-mcpPass
- No critical advisory in the package or its dependenciesthe package checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubAn ordinary task list forgets the moment you tick the box. Your AI agent forgets the moment the session ends.
Everybody patches that in their own way: a NOTES.md hidden behind
.gitignore, a Markdown file per session, a TASKS.md nobody keeps up to date.
They go stale, they pile up, they get lost between branches, machines and
projects — and the agent rereads all of it, every session, at full price. The
assistant is brilliant at the file in front of it and forgets the picture: why
something was decided six months ago, what failed last time, what is still left.
Tisty is the memory underneath. Tasks that keep how each thing was solved, with their steps and a dated journal. Documents that keep what you know, one per subject, corrected in place instead of piled up. All of it on your own disk: visual and comfortable for you, and for your agent a local MCP server that says what moved since last time and reads an outline first, then only the section it needs.
It is open source: read it, build it, run it, or take one of the signed releases already out there. Nothing is hidden and all of it can be audited.
I am not a company. I am a developer who kept solving the same problem twice, so I built the notes, documents and task manager I wanted and gave it away. It is meant to stay small and useful, not to grow a thousand features nobody uses. No ads, no telemetry, no accounts, no subscriptions — a local-first productivity tool that lives on your machine and nowhere else.
Why people choose Tisty:
- Memory that outlasts the session — your agent starts from what moved, the task it was on and what it noted yesterday, not from a blank chat.
- Made for agents as much as for people — an outline costs a few hundred tokens, a read brings one section, and picking up again brings only what changed: a fraction of rereading your Markdown files.
- Finishing keeps everything — a closed task goes to the archive whole, and a search answers «how did we solve this?» with the line that says it.
- 100% local — your tasks, your journal and your documents live on your computer and go only where you send them. No server of ours, no account. If you sync two machines, you can ask Tisty to leave the largest attachments in that shared folder instead of carrying them onto every disk; it never does that unless you choose it.
- Documents that do more than text — books in pages, diagrams, formulas, code, widgets and attachments, all of it plain Markdown any other editor still opens.
- Truly free — no premium tier, no feature gates, no trial. AGPL v3.
- Your data outlives the app — plain text and Markdown on your own disk,
readable with
catand searchable withgrep. - Fast and native — a Rust core inside a Tauri window: it starts quickly, stays small, and looks like it belongs on both systems.
I use Tisty every day on macOS and Windows. If something feels off, open an issue — this project keeps improving because of real-world use. Questions, ideas and how you use it go to Discussions.
Each person keeps their own Tisty, by design. A developer, a PM and a QA each have their own tasks, documents and lessons, and their own agent working from them. When someone needs what you know, you hand them the document through Folio. No assignees, no permissions, no boards: if you need to run a team, Tisty will not carry that.
Table of Contents
- Real Problems, Real Fixes
- Tasks and Documents, for You and Your Agent
- A Day With Your Agent
- What It Costs Your Agent
- Share What You Know With Folio
- MCP Server
- Tools
- Why I Built This
- What It Is / What It Isn't
- What Makes It Different
- Documents
- Who Is This For?
- The Idea It Is Built On
- Getting Started
- What It Does
- Your Data and Privacy
- Two Machines, If You Have Two
- An Assistant, If You Use One
- What It Does Not Do
- FAQ
- Alternatives to Obsidian, Notion and Todoist
- Localization
- Other Tools by the Same Author
- Support the Project
- Standing On
- Contributing
- Licence
- Project health
Real Problems, Real Fixes
What people actually run into when they work with an AI assistant for months, and what happens instead when the memory lives in Tisty.
| The problem | With Tisty |
|---|---|
| Developer: every new session you explain the project to your agent again | It asks what moved since last time, opens the task Move payments to v2 with its ticked steps, and reads what it noted yesterday: the webhook fails on old signatures; retrying ruled out. It carries on from there. |
Developer: your NOTES.md grew to 256 KB and the agent rereads it every time |
It lives as documents split by subject, in pages. The agent reads the outline and the one section it needs — about 94% less than the whole file. |
| Anyone: you solved this eight months ago and cannot remember how | A search for timeouts on save brings back the archived task as it was left: its steps, its journal, and the line saying the cause was a missing index. |
| PM: a month later somebody asks «why did we decide this?» | One living document per subject, Checkout decisions, each decision dated with its why. The agent finds it and quotes it instead of reopening the debate. |
| QA: the same screen breaks again and nobody remembers last time's cases | The archived regression task keeps its cases as steps, with what was seen in each. |
| Handover between PM and PO, or developer and QA, pasted into a chat | You hand over the document through Folio: encrypted on your machine before it leaves, signed by you, gone on its own after days unused. |
| Business rules that must not land in somebody else's database | Tisty keeps them on your disk and sends them nowhere. What your agent reads goes where that agent goes, so pair it with one your company allows. |
| At home: the bank paperwork that comes back every year | Next year, the archived task tells you how you did it last time. |
Tasks and Documents, for You and Your Agent
Tisty keeps two kinds of things, and the same two serve you and your agent. Something you will do is a task. Something you will come back to is a document.
Tasks: what to do, who does it, how it was solved
- Priority, by its name — the Eisenhower matrix: do, decide, delegate, drop. A date and a deadline are kept apart, so a planned day that slipped is late and only a deadline that passed is overdue. Lists, tags, and a reminder for what cannot wait.
- Steps and parts — a big job splits into parts, each with its own steps and its own day.
- Shared work, clear ownership — what your agent files is its own to keep true: it describes it, plans the steps, ticks each one when it is done and notes what it learns. What you wrote stays yours: the agent only adds — a journal entry, a reminder, a file — and gives its word that a step or the whole task is done, for you to confirm. Closing is always yours, and every entry says which agent wrote it.
- A journal — dated notes that are never rewritten: what was tried, what was ruled out, and why.
- A page per task — Description, Done when, Steps, Notes and When it closes: the agent knows when it is finished before it starts.
- One ticket, one task — filed with its source, a ticket or a thread, the same work is never filed twice.
- The archive — a closed task is kept whole, and a search answers «how did we solve this?» with the line that says it.
Documents: what you know, one per subject
- One living document per subject — it opens with what holds today, then the subject, what is out of scope, the decisions dated with their why (a replaced one is struck through, not erased) and its history.
- Corrected in place — the passage that changed is rewritten; no second copy is piled beside the first.
- Pages for what is long — a runbook, an annex, a book in chapters — with folders, languages, tables, diagrams, formulas and a PDF of its own.

A Day With Your Agent
What an agent connected to Tisty does with all that, on a real piece of work:
- It asks what moved since its last session, and who moved it, instead of rereading everything.
- It opens the task it was on, which Tisty names for it. Done when says when it is finished, and the unticked steps say what is left.
- It searches the archive before proposing anything. If it was solved before, it starts from there.
- It reads the module's document by its outline, then only the section it needs, and keeps to the decisions and to what is out of scope — so it does not reopen settled debates or wander off.
- It ticks each step when it is done and notes what it ruled out, so the next session, or another agent, does not repeat the failed attempt.
- When a task's page grows long, it compacts its own notes into one dated digest — state, decisions, what was ruled out. The journal stays whole.
- It ends by saying what it did and how it knows it holds. You review it and close it.
- After reading a long document, it leaves a summary for the next agent to choose by. When the document changes, the summary is marked stale.
Your tasks tell your agent what is left and how far it may go; your documents tell it what was already decided. What it learns stays written down for next time.
What It Costs Your Agent
Most MCP servers talk to your agent without pause. Tisty knows what each answer costs, and keeps cutting it. Measured on a 256 KB Markdown work log, against an agent that rereads the whole file every session:
| The agent… | Spends, with Tisty | Saving |
|---|---|---|
| Picks up the work, with nothing new | about 1% | 99% less |
| Looks for something solved months ago | about 3% | 97% less |
| Looks up one subject: the outline and one section | about 6%, 12% at worst | 88–94% less |
Where the saving comes from:
- No document holds more than 64,000 characters, so a log that size is kept as subjects in pages, never as one wall of text.
- No read brings more than about 12,000 characters. Past that, a document asked for whole comes back as its outline.
- A task's page comes whole only while it is short, about 4,000 characters. Past that come its sections and the agent's latest note, and its journal is counted by size, not by number of notes.
- The outline says what each section weighs before anything is opened.
- Picking up again brings only what moved since the last time.
- What is finished is archived, and costs nothing until it is searched.
- The outline points at repeated subjects and headings, so they can be consolidated rather than read twice.
Connecting costs something too: the description of Tisty's tools weighs about a sixth of that log, a third less than it did, and a test keeps it from growing. An assistant that loads tools only as it uses them does not pay it whole; one that loads every tool each session saves 72–83%, and below some 50 KB of notes a plain file is cheaper. The counts are characters, with the JSON each answer carries included, and tokens follow them closely.
Share What You Know With Folio
When somebody else needs what you know — your PO, the QA joining the project, another team — you hand them the document through Folio by Tisty. It is encrypted on your machine before it leaves, the key travels in the link where no server sees it, every version is signed by you, and the link stops working on its own after the days without use you choose. They read it in any browser with no account, or edit it in their own Tisty. Your memory stays on your disk; Folio only carries a copy. More in Your Data and Privacy.

MCP Server
Tisty is also a local MCP server for tasks, todos and notes. Through it an assistant files tasks with steps, dates and reminders, writes and edits Markdown documents, and searches open and archived work — on your own disk, with no account, no API key and nothing sent over the network. It needs the Tisty app, from Getting Started, and Node.js 18 or later for the launcher.
The easiest way is Settings › Assistants in Tisty: it finds the assistants
on this computer and connects the one you pick. By hand, any assistant that
starts a server by command takes the tisty-mcp launcher from npm, which finds
the Tisty installed here and starts its own server:
{
"mcpServers": {
"tisty": {
"command": "npx",
"args": ["-y", "tisty-mcp"]
}
}
}
| Assistant | Add Tisty |
|---|---|
| Claude Code | /plugin install tisty --marketplace rgdevment/mcp-plugins |
| Claude Desktop | Settings › Developer › Edit Config, and add the JSON above |
| Cursor | Cursor Directory, or the JSON above in ~/.cursor/mcp.json |
| GitHub Copilot in VS Code | code --add-mcp '{"name":"tisty","command":"npx","args":["-y","tisty-mcp"]}' |
| Gemini CLI | gemini extensions install https://github.com/rgdevment/mcp-plugins |
| Codex | codex mcp add tisty -- npx -y tisty-mcp |
Connect it one way, not both, so the assistant does not start Tisty twice, and restart the assistant afterwards. More in Assistants and MCP.
Things to ask once it is connected:
- "Add a task to renew my passport before March, with the steps it takes."
- "What is on my todo list this week, and what is overdue?"
- "How did I fix the timeouts on save last year? Look in the archive too."
- "Write a document with my notes from today's call and file it in Clients."
- "Plan the release as tasks with steps, and tick them off as you go."
- "Remind me of the dentist the evening before, at 8."
Tools
What tisty mcp offers an assistant, by what it works on. It never closes or
deletes: say_done leaves a task for you to confirm, and flag_doc leaves the
deleting to you. Each tool is described in
MCP tools.
- Tasks — file one with steps and a date, plan and tick its steps, set
when it rings, move its day, say it is done:
propose,describe,plan,tick,untick,reword_step,unplan,rename,move,remind,reschedule,say_done,say_not_doing,read - A task's journal and files —
note,reword_note,attach - Documents — write one, add to it, change a passage or a table, read only
the part it needs:
write_doc,append_doc,edit_doc,edit_table,read_doc,outline_doc,sum_up,restore_doc,import_doc,export_doc,archive_doc,flag_doc - Folders, pages and languages —
docs,folder,file_doc,page_doc,tongue_doc - Finding things — open and archived work, lists and tags:
find,catch_up - How to work here —
rules,language,help
Beside the tools, it offers five ready-made requests your assistant shows as
commands (pick_up, leave_off, plan_task, solved_before,
keep_decision), and your documents to mention with @, a long one as its
outline.
Why I Built This
Organising your day is harder than a list makes it look. There are more moving parts than fit in your head, plans shift under you, and something you thought was small turns out not to be. Which is why finishing it feels good.
But look at what the task gathered on the way. The steps it actually took. The notes you wrote while working it out. What you looked up, what it turned out to connect to, the documents you leaned on. That is where the effort went.
Mine looked like "fix the intermittent timeouts on save". By the time it was done it had collected the ticket, the commit, and two paragraphs explaining that the real cause was a missing index on a table nobody was looking at.
Eight months later the same thing happened somewhere else. I remembered solving it. I could not remember how — and the note that held the answer had gone with the tick.
That is the whole reason Tisty exists. A task is not a line you cross out. It is a tree: the steps, the journal, the files and the documents that grew around it while you worked. Finishing it should not prune it.
I wanted it to stay mine, too. On my disk, in files I can open without asking anyone. So I built the thing I wanted, used it until it stopped annoying me, and put it here in case it is the thing you wanted too.
What It Is / What It Isn't
It is a personal task manager where finishing something is the beginning of its useful life. Tasks carry a description, a journal, steps and attachments; when you complete one it moves to the archive, and search reaches all of it, documents included.
It is a place to write, too. Documents are not a notes field bolted onto the tasks: they are Markdown files that grow into books, with diagrams, formulas, code and their own PDF.
A task or a document? A task is something to do: it ends, often soon, and then it stays, so that months later you can look up how you solved it. A document is something to keep and read again — a manual, a recipe, the notes on a client — that grows and lasts for years. Something you will do is a task; something you will come back to is a document. A spike is the clearest case: a task whose page gathers what you found out — notes, recordings, code analysis — split into parts that each get done, then completed and archived — and a year later a search still brings back how it was solved, every step of it. That is why a task has a page: it is also a document, one with an end.
flowchart TD
A[Something comes up] --> B{Will you do it,<br/>or come back to read it?}
B -->|Do it| T[A task]
B -->|Read it again| D[A document]
T --> P[Its page: notes, steps,<br/>files, recordings]
P --> S{Too big for one go?}
S -->|Yes| K[Split it into parts]
K --> C
S -->|No| C[Complete it]
C --> R[The archive:<br/>search finds how you solved it]
P -.->|You learned something<br/>you will need again| D
D --> G[Read, correct and add to it<br/>for years]
It is one person's. Each person keeps their own Tisty, with their own agent working from it, and hands a document to somebody else through Folio. No assignees, no permissions, no boards. If you need to run a team, Tisty will not carry that, and you deserve to know before you install it rather than after.
It is not something I sell. Nothing is locked, nothing expires, and there is no version of this with more in it. It is a program I wrote for myself and gave away.
Your data is files. Plain text on your own disk, readable with cat and
searchable with grep. If Tisty disappeared tomorrow, everything you wrote
would still be there and still make sense.
Tisty MCP questions
How do I add Tisty MCP to Claude Code?
Run claude mcp add tisty -- npx -y tisty-mcp in your terminal. Add --scope user to make it available in every project.
How do I add Tisty MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What is Tisty?
Tisty is a local-first productivity tool for notes, documents, and tasks that provides a memory layer for both users and AI agents.
How does Tisty help my AI agent?
It allows agents to pick up where they left off by reading outlines and specific sections instead of entire files, saving tokens and context.
Is my data private?
Yes, Tisty is 100% local with no accounts, no subscriptions, no telemetry, and no cloud server.
What file format does Tisty use?
Tisty uses plain Markdown files stored on your own disk.