How does Ownhand learn from my edits?

After you send a draft, your agent calls send_feedback with the exact text you sent, and Ownhand compares it with the draft it wrote: a reason you give in your own words becomes a rule right away, a pattern in your edits becomes a rule the second time it shows up, and the text you sent becomes a new sample of your writing. ChatGPT memory, Claude memory and GitHub Copilot Memory also learn over time at no extra cost, but they learn from your chats and your requests, and none of them is built to compare a draft with what you actually sent.

By Jordan Gibbs, founder of Ownhand at Thalient Labs. Updated 2 October 2026.

Most writing tools learn from what you tell them. Ownhand learns from what you do: the gap between the draft it handed you and the message you actually sent. This page covers that loop, what each report changes, how to see and undo it, and free tools that learn in a similar way.

The loop, step by step

1. Your agent writes a draft, then calls write with the draft and an occasion, such as chat_dm or email_cold.
2. Ownhand returns the text in your voice with a request_id. Your agent shows it to you and sends nothing without your OK.
3. You edit it if you want, and send it yourself.
4. Your agent calls send_feedback with the request_id and the exact text you sent. Learning starts in the background.

Step four is the one people skip. Without it, your Hand only knows the samples you gave it on day one. With it, every message you send becomes evidence about how you write. The next draft starts closer to what you would have written anyway.

What your agent reports

Include the final text exactly as it went out, character for character. An edited report without it is refused. A reason is optional but worth a lot. Write it in your own words, like "too stiff for Slack". Reporting the same verdict on the same request twice is safe. The second report returns the first result.

What one report changes

Ownhand first measures how much you changed, word by word. If less than about 3% of the text changed, it treats the edit as a typo or a fact fix and doesn't look for rules in it. Anything bigger, or any report with a reason, goes to a separate learning model. That model compares three texts: your original draft, the rewrite, and what you sent.

Rules come in four kinds: banned phrase, style, structure, and word choice. Each one applies everywhere, or only to the occasion it came from. So cutting the greeting from Slack DMs doesn't cut it from formal email. The learning model is told to skip corrections of content or facts, and anything specific to one message's topic. Fixing a date teaches nothing about your voice, so it doesn't become a rule.

Each rewrite uses up to 20 rules. Pinned ones go first, then the ones seen most often. Your Hand keeps up to 50 samples. When it's full, the oldest approved drafts go first, then the oldest of your own texts. What you wrote yourself outlasts what you only accepted.

What an edit teaches

You see it best with two writers given the same AI draft. Say your Hand produced the second version and you sent something like the first. The difference is what the report carries.

These examples are real output from the live API. Each AI draft was rewritten by a demo Hand: a fictional writer (an engineer, a founder, an ops lead, a designer or a consultant) built from a handful of samples.

The engineer starts in lowercase, abbreviates end of day, and drops the subject and the verb. The consultant keeps full sentences and a formal apology. Report that kind of edit once and the edited text is saved as a sample straight away. The report also proposes rules, such as starting chat messages in lowercase. A second report with the same change makes those rules active.

See it, change it, undo it

Open your Hand in the dashboard. You'll see its style card, every learned rule with its status and how many times it has been seen, and its version history. Learning raises the version number each time it finishes.

• Pin a rule to keep it at the front of every draft.
• Reject a rule to stop it applying. It stays in the list so you can see what was learned.
• Reactivate a rule you rejected earlier.
• Roll back to any earlier version. The rollback is saved as a new version, so it can be undone.

Your agent can do the same things through tools. get_hand shows the style card and the active and pinned rules. update_hand pins, rejects or activates a rule by its id.

What it does not learn from

• Drafts nobody reports. If your agent never calls send_feedback, nothing changes.
• A rejection with no reason and no text. Ownhand records it, but there is nothing to learn.
• The thread you were replying to. It is used for that one request and never stored.
• Anyone else's writing. Learning changes only your own Hand.

Each report costs about half a cent. For what the learning model receives and who runs it, see whether Ownhand is safe.

Other tools that learn over time

ChatGPT memory and Projects

1. Open Settings, then Personalization, then Memory, and turn on saved memories and chat history.
2. Tell it directly: "Remember that I never use exclamation marks and keep Slack messages under 20 words."
3. For one kind of writing, make a Project and pick project-only memory, so its notes stay out of your other chats.

Saved memories are the details you ask it to keep. You can view and delete them in the same menu. Custom instructions, also under Personalization, hold the standing rules.

Claude memory and Projects

1. Open Settings, then Memory, and turn on Generate memory from chats. It is on the Free, Pro and Max plans. On Team and Enterprise it stays off until each member turns it on.
2. Say "remember this" after a correction you want kept.
3. Put standing rules in Settings, Instructions for Claude, or in a Project's instructions. Each Project keeps its own memory.

Everything Claude remembers is listed by topic in Settings, Memory. You can read and edit it there.

GitHub Copilot Memory

Copilot Memory stores facts about a repository and your own preferences. It's for the cloud agent, code review and the Copilot CLI. Repository facts carry citations to the code and are checked before use. Anything unused for 28 days is deleted. You can review and delete entries in Copilot settings.

Cursor rules

Cursor rules do not learn on their own. You write them: project rules in .cursor/rules, an AGENTS.md file in the project root, or User Rules in Customize, Rules. To make them learn, add a line each time you fix the same thing twice.

These are enough when you mostly write in one app, your style is easy to put into a few lines, and you are happy to say "remember this" when something is off. They fall short when you edit drafts silently, or when you write in several tools and want one voice across them. For the setup in each app, see how to make Claude write like you and the same for ChatGPT.

Why edits are the signal

In a 2024 paper, Ge Gao and colleagues introduced CIPHER. It infers what a user prefers from their past edits, writes it down, and adds it to later prompts. In their tests it had the lowest edit cost of the methods compared, with little extra model cost. Ownhand works in the same broad way. It writes down plain rules from your edits and leaves the model itself unchanged. That's why you can read and reject each rule.

Make sure your agent closes the loop

1. Copy the agent blurb from the docs.
2. Paste it into CLAUDE.md, AGENTS.md, your Cursor rules or your assistant's custom instructions.
3. After your next sent message, check the dashboard: the request should show a feedback verdict.

Follow-up questions

Do I have to call send_feedback myself?

No. Your agent calls it after you send the draft. The agent blurb in the docs tells it to do that every time, with the exact text you sent. If it forgets, say what you sent and ask it to report it.

How many edits does it take before drafts change?

One, if you say why. A reason like too formal becomes an active rule after that one report. A change without a reason needs to show up twice. Each edited message is also saved as a new sample as soon as learning finishes, so it shapes the next draft for that occasion.

What if it learns a rule I did not mean?

Open your Hand in the dashboard and reject the rule. It stops applying to new drafts right away. If a whole round of learning went wrong, roll the Hand back to an earlier version. The rollback saves as a new version, so you can undo it.

Does my feedback train a model that other people use?

Your feedback changes only your own Hand. One person's writing never shapes another person's Hand. The learning step runs on a model, and the provider may use those inputs to improve its models. The safety page explains what is sent.

Sources

Checked on 2 October 2026. If something here is out of date, email hi@thalientlabs.ai and we will fix it.

• Gao et al., learning latent preference from user edits (arXiv, 2024): CIPHER: infers a written preference from past edits and uses it in later prompts, with the lowest edit cost of the methods tested
• OpenAI Help: Memory in ChatGPT: saved memories and chat history; Settings, Personalization, Memory
• OpenAI Help: Projects in ChatGPT: default memory or project-only memory
• OpenAI Help: ChatGPT custom instructions: Settings, Personalization, Custom instructions
• Claude Help Center: chat search and memory: Settings, Memory; Free, Pro and Max; separate memory per project
• Claude Help Center: personalization features: profile instructions and project instructions
• GitHub Docs: About Copilot Memory: repository facts and user preferences; unused entries deleted after 28 days
• Cursor Docs: Rules: project rules in .cursor/rules, User Rules, AGENTS.md
• Ownhand source code: the learning step, its thresholds and the feedback tool