Features

Five things Grasppy does that your AI tools don't.

Everything below follows one piece of work through its life — caught as you go, kept where you can reach it, worked on by two agents, distilled into one current answer, and governed by a plan the agents cannot drift from.

Join Free Start at the beginning

Runs on the AI subscriptions you already pay for. No API keys, and nothing metered by us.

Feature 1

Auto-Capture — nothing is lost, and you do nothing.

A small helper runs on your machine and files every Claude Code and Codex session as it happens. No button, no export, no remembering. By the time you realise a conversation mattered, it has already been kept — which is the only way this ever works, because nobody tags the chat that turns out to be important six weeks later.

A robot at rest while chat sessions file themselves into a folder
●
It runs whether you think about it or not. The capture daemon watches your sessions locally and files them as they finish. You find out it was working when you go looking for something.
●
Sixteen platforms, not one. Claude, ChatGPT, Gemini, Grok, Cursor, Windsurf, Copilot, Perplexity and more — through the browser extension or direct import.
●
Free, and the entry point. Capture costs nothing and needs no account upgrade. Everything else on this page is built on the corpus it quietly accumulates.

The free capture app The browser extension

Feature 2

Your history — every conversation, every platform, and it leaves with you.

Every conversation, from every platform, in one place — and it does not live inside a company you pay monthly. Stop your Claude subscription tomorrow and your Claude history stays with you. That is the difference between a search feature and ownership.

A robot walking away carrying a box of conversations with an open padlock
grasppy-exports/
mydocs/   the documentation
myplans/  the plans
myrules/  the rules
myskills/ the skills
mymemory/ what it remembers
EoC/       every session close

format: plain Markdown
location: a folder you chose
1
Organised without you organising it.Each conversation is read and broken into topics, decisions, entities and artifacts, then cleaned and indexed. You never file anything, and it is still findable a year later.
2
Markdown in your own folder.Not a proprietary database you can export from if the button still works. Plain text files on your disk, readable with anything, for as long as you keep them.
3
It survives the tools it came from.Vendors change plans, retention and pricing. Your record of how you built something should not be a hostage to any of that.

The analysis behind it runs in seven stages and produces more than a transcript: an architecture diagram, an entity-relationship diagram, a decision tree and a dependency map, generated from the conversation itself. Every file your assistants wrote is pulled out too, versioned, so the eleventh revision of a script is still there beside the first.

Feature 3

Relay — your plan, worked by two agents.

Every fix read by something that didn't write it. Claude Code and Codex take turns on one plan; each finding gets a number and stays open until the other agent independently confirms it. A model checking its own work reproduces the assumption that caused the bug — so it never gets to.

Two robots passing a checked finding across a shared plan
●
Neither signs off alone. Closing an issue is a claim. Only the counterpart can confirm it, and the rule is enforced in the database rather than asked for in a prompt.
●
You are asked, not consulted constantly. Committing, pushing, deleting data and database changes always need you. Everything else is theirs, and they carry out what you approve.
●
The audit trail is a by-product. Every turn, every command, every finding and who confirmed it — produced by the work rather than written up afterwards.

How Relay works

Feature 4

The source of truth — a thousand conversations, one current answer.

Conversations are sediment — contradictory, superseded, the same decision made three different ways across six weeks. Documentation is the rock. Grasppy gives you the process that turns one into the other: content checked in from the work, reviewed by you, versioned, and current because a person approved it rather than because a machine promised to keep it fresh.

A scattered pile of notes resolving into one current, tagged document
A
Written from the work, not beside it. Your agents produce check-in files from what actually happened. You see exactly what changes before anything is applied.
B
You approve every change. Check-in shows the diff node by node. Nothing is rewritten silently, and auto-generated documentation nobody signed off is not what this is.
C
Your codebase is mapped too. My Code builds a dependency graph your agents read before they edit — what imports a file, what breaks if its signature changes, and where the hidden dependents are.

Feature 5

Plans — the blueprint your agents can't drift from.

Parts, chapters, phases and tasks — and an agent that reports which phase it is working in, checked against the code that actually exists. Not a task list you look at. The structure the work is done against, which is the difference between an agent that wanders after twenty minutes and one that is still on the same problem an hour later.

A robot checking a code window against a blueprint checklist
→
The agent reads it and reports back. Phases are declared, not inferred. You can see how far the work has actually got rather than guessing from the last message.
→
Verified against reality. A plan can be checked against the repository it describes, so "done" means the code exists rather than that somebody typed done.
→
And the same for the rest. Skills, rules and memory work the same way — written once in Grasppy, synced to your machine, and read by every agent you use.

Start with capture. It costs nothing.

Everything else is built on the conversations it quietly keeps for you.

Join Free See pricing