Turn Every Run Into Persistent Learning

An agentic workspace should improve through use. The basic mechanism is a feedback loop: plan the work, execute it, identify what succeeded and failed, compress the learnings, and update the local instructions. Repeated patterns can later be promoted into global instructions after human review.

This creates a practical form of cumulative learning without retraining the model. Future sessions begin with better constraints, fewer dead ends, and clearer knowledge of the environment.

The local loop is:

1. Plan a feature, task, research objective, or operating procedure.
2. Execute it with the current harness and instructions.
3. Observe delays, mistakes, unnecessary tool calls, failed approaches, and successful shortcuts.
4. Ask how the same result could have been reached faster, with fewer steps, or with fewer tokens.
5. Distill the answer into a short, reusable rule.
6. Add the rule to the local instruction file.
7. Apply the updated file on the next task.

For example, an agent may edit one file through many sequential calls even though it could have read the complete file and replaced it in one write. The durable lesson is not a record of every edit. It is a concise rule: when making widespread changes to one file, prefer one coherent rewrite over many serial edits when that is safe and appropriate.

A second recurring pattern is maintaining a log of what not to do. This functions like experiment notes. It records approaches that repeatedly fail, tools that should not be retried indefinitely, conditions under which a method breaks, and actions that waste context. By excluding known-bad regions of the solution space, the agent can focus future effort on the remaining possibilities.

The global loop operates at a slower cadence:

1. Accumulate many local runs across several projects.
2. Analyze conversation histories or project notes for repeated patterns.
3. Identify failures or preferences that occur across workspaces rather than in one project.
4. Distill them into short, high-information-density rules.
5. Manually review for correctness, contradiction, and overgeneralization.
6. Add only the highest-value rules to the global instruction layer.

Human review is essential at this stage because global rules affect every future project. Agentic steps also compound uncertainty. If three independent steps were each 90 percent reliable, the combined probability of all three being correct would be about 73 percent. A mistaken global rule can therefore spread a local misunderstanding across the entire workflow.

Without persistence, every session pays the same discovery cost. The agent repeatedly searches for the same files, retries the same broken integrations, uses the same inefficient editing pattern, or overlooks the same available capability.

A learning loop converts time and token expenditure into reusable intellectual capital. The immediate task produces an output, but it also produces a better operating system for the next task. As the instruction layer accumulates valid constraints, the search space narrows and similar work can become faster.

After any meaningful task, run a short retrospective. Useful questions include:

• What did the agent attempt that did not contribute to the result?
• Which tool calls were repeated or avoidable?
• Which project fact had to be rediscovered?
• Which capability was available but not used?
• Which sequence could have been collapsed into one operation?
• Which failure should future runs stop retrying?
• Which successful method is likely to recur?

Convert only reusable answers into instructions. A good rule is short, specific enough to change behavior, and broad enough to apply again. A poor rule is a detailed narrative of one incident or a command that only applies to a file that will never be touched again.

Use separate places for local and global learning. A project-specific API failure belongs locally. A repeated tendency to skip documentation across unrelated integrations may belong globally. Promote a rule only after enough evidence shows that it is not a one-off.

Review the instruction set periodically. Merge overlapping rules, remove obsolete ones, and look directly for contradictions. The review should preserve high-value constraints while preventing the file from becoming an unfiltered history of every interaction.

Persistent learning can fossilize mistakes. An agent may incorrectly explain why an attempt failed, or a temporary workaround may later become unnecessary. A rule that improves one task can damage another when generalized too broadly.

The loop also has a maintenance cost. Every new rule consumes context, and excessive rules can create slower reasoning or conflicting priorities. The goal is not to record everything. It is to preserve the smallest set of learnings that reliably changes future performance.

Treat each run as both execution and research. Capture reusable successes and failures locally, promote only repeated cross-project patterns globally, and require human review before a lesson becomes a universal rule.