How an agent learns as it works

Dropstone is a self-learning agent. It records what it learns from corrections, from finished work, and from sources you ask it to study, and it uses that the next time without being told. Here is the loop.

An assistant that forgets everything between conversations can only ever be as good as the instructions you give it each time. Dropstone is built around a different idea: it should get better at working with you the longer you use it, without you managing that.

This page describes the loop that makes that happen.

The loop

Every task Dropstone works on runs through the same four steps.

Recall
Before it starts, it checks its memory for anything relevant: standing rules, facts about this project, things it has studied, past conversations on the same subject. Whatever fits is brought into the task.
Work
It does the job, applying what it recalled. When a memory changes what it does, it says so in one short line so you can see the connection.
Catch
The moment you correct it, reject an approach, or state a preference, it records the lesson. It does not wait until the task is finished, because a correction is the most useful thing it will learn in a session and it should not be lost if the conversation moves on.
Reflect
After finishing something non-trivial, it asks whether there is a durable lesson in what just happened. A convention it discovered in your codebase. A gotcha it hit and worked around. An approach that failed, and why. If there is, it records the general lesson, not the specific detail.

The next task starts at Recall again, with a slightly better memory than before.

What counts as a lesson

Dropstone records the reusable strategy, stated generally enough to apply next time.

factThis project keeps its configuration in a single typed file; edit that rather than scattering constants.

Not "the file config.ts had a typo on line 40". The typo is one task; the convention is every task after it.

It records the why alongside it when there is one: what happened that taught it this. That context is what lets it judge later whether the lesson still applies.

It does not record things that are true of one task only, and it does not record something it already knows. If a lesson matches one it already has, it keeps the existing one rather than adding a duplicate, and it will not tell you it learned something new when it did not.

Studying, on request

Beyond what it learns from working, you can point Dropstone at something and ask it to learn it. A page, a document, an API reference, a specification. It reads the source, keeps what it learned in its own words, and attaches where it came from.

The next time that subject comes up, it draws on what it studied and cites the source, rather than searching the web again for something it already read. When two things it studied disagree, it prefers the more recent one and tells you they conflict.

What it will not do

It will not pretend. If it has no memory relevant to a task, it says nothing about memory rather than implying it remembers something it cannot point to.

It will not forget on its own judgement. Only you can remove a memory, and only when you ask. See Change or forget a memory.

It will not learn from an incognito chat. Nothing said there is recorded.

Why this is different from a system prompt

You could put your preferences in a fixed instruction and paste it into every conversation. The difference is who does the work, and what happens when things change.

With a fixed instruction, you maintain it. You notice when it is out of date. You remember to include it in every tool you use.

With Dropstone, the memory maintains itself from the corrections you were going to make anyway, it follows your account into every surface without being pasted, and you can see and edit all of it whenever you want.