Correct once: the lesson comes back when the work needs it

The idea

When you correct a Crewshal AI worker once, the platform keeps the correction as a lesson. A lesson tied to folders goes back to the worker when later work reaches those folders, and it stays out of work where it does not apply. Lessons tied to folders run only in the lab for now; in production, a lesson loads when its words match the work.

The problem
Many AI tools lose a correction when the chat ends, so people repeat the same instruction in every new task.
Why it matters
You say it once. The lesson reaches the next task that touches the same folders and stays out of unrelated work.
Where it stands
Shown in a lab run as of One owned lab run with a real model showed it end to end on November 16, 2026. Lessons from corrections run in production; lessons tied to folders need the AI worker's own computer, which is switched off in production.

Crewshal team · · 4 min read

Recorded run · Owned lab, real model · November 16, 2026

One correction, two tasks

An AI worker fixes two issues in a team repository. Between them its owner gives one correction, and the second fix follows it.

Step 1 of 14Task 1

TaskTask 1 arrives

The worker gets its first task: fix issue #1, "Search misses issues when the letter case differs". The task says where the issue is and that the team's rules are in the repository. Nothing more.

InputThe task, as given

Fix issue #1 on the team's forge. The team's rules are in the repository.

InputThe issue

Issue
#1 Search misses issues when the letter case differs

Where it ran. A real model (Claude Opus 5.5 through Claude Code) on the platform, with a lab Git forge, mail server and worker computer in Docker. The owner's two steps, the correction and the lesson review, were scripted calls to the product's own API; the worker, the platform and the verifier did everything else live. Lessons tied to folders need the worker's own computer, and worker computers are off in production. A time marked “about” is an estimate: the record's creation time plus its recorded duration.

The recorded files behind this replay
  • Run record: stages, gates, plans, checks, model calls sha256 4ba54d9a6db3
  • The correction, the lesson and its memory, as stored sha256 67da2f6330ef
  • Pull request #3 (task 1), as merged for review sha256 5af8bd330501
  • Pull request #4 (task 2), as merged for review sha256 27fb7e4648ba
  • Verifier's verdict on pull request #3 sha256 9c5e9cb39b9a
  • Verifier's verdict on pull request #4 sha256 5d17ba1ca906
  • Worker screenshot before the task 2 fix sha256 68ba07a9a4c8
  • Worker screenshot after the task 2 fix sha256 dc4feacae787

Why it matters

A correction that disappears when the task ends must be given again in the next task. That costs your time, and you must remember every rule you already gave.

If every past correction went into every task instead, each task would carry more text with each correction. A rule for one part of a repository could also mislead work in another part.

Crewshal keeps the correction once and ties it to the folders where it applies. You give one sentence, and the platform does the bookkeeping. By default, a person reviews each lesson before it becomes a rule.

How it works

  1. You correct. You give feedback on a finished piece of work, in plain words.
  2. The platform writes a lesson. A model reads your words and writes the lesson: the rule, the reason and how sure it is. The folders do not come from the model. The platform takes them from the files that the worker wrote with its write tool in that task. A correction that replaces an earlier memory keeps that memory's folders.
  3. A person reviews it. By default, an owner, admin or approver accepts or rejects each lesson. Two exceptions: an organization can turn on automatic acceptance for procedures and preferences that recur in 3 or more work items and cite a recorded failure or correction, and an explicit instruction or correction from the person who asked for the work is accepted without a review, as that person's own words.
  4. It waits in memory. An accepted lesson goes into the worker's memory with its folders.
  5. It loads when the work touches a match. In each later task, the platform records which files the worker reads, writes or runs. It reads the paths from the worker's own calls, never from what a tool printed. When a path is inside a lesson's folder, the platform adds the lesson to the worker's context from then on.
  6. The worker can also look it up. A worker can read its own memory, so it can find the lesson before it touches a file.

What the run showed

The replay above is a recorded run from November 16, 2026, in an owned lab with a real model. The owner's two steps, the correction and the lesson review, were scripted calls to the product's own API.

  • In task 1, the platform sent the work back once because one claim had no test, and the worker added a fifth test. None of the five test titles named the issue. Four of them fail without the fix; the fifth guards behaviour that the old code already had.
  • The owner gave one correction. The platform made a lesson for the folders src/** and test/**, because task 1 wrote one file in each. The owner accepted it.
  • Task 2 started without the lesson in its context. The worker first read its memory. It then read eight files on its computer, among them test/format.test.js, which is inside test/**, and the lesson was in a later context. Its first plan cited the lesson. public/format.js, the file with the fix, is in neither folder.
  • The new test was titled "one issue is counted in the singular (#2)".
  • The platform's verifier approved both pull requests. In task 2, the platform's completion checks then sent the work back twice before it passed: first because the tests had not run after the last command, no screenshot showed the page after it and one claim had no test, then because the tests had not run again.
  • Hidden tests that the worker never saw, a check of the lab and not of the product, passed 6 of 6 and 2 of 2. Nobody stepped in beyond the two planned owner steps.
  • The whole run passed 56 of 56 checks in 33 minutes. Its model calls cost USD 9.33 at list price.

Limits

  • Lab, not production. Lessons from corrections run in production. Lessons tied to folders need the worker's own computer, and worker computers are off in production.
  • One run, one model. The run shows the whole mechanism once, on one model. It does not measure how often lessons help.
  • The first match is not recorded. The record shows that the lesson was absent at the start of task 2 and present in a later context. It does not say which path matched first.
  • Folders follow the written files. Only files written with the worker's write tool count; edits through shell commands do not. A correction about another part of the repository still gets the folders of the files that the corrected work wrote.

Frequently asked questions

Does the worker forget a correction when I change the model?

No. The lesson is stored by the platform, not in a model's chat, so a new model does not lose it. A later task gets it when its work matches the lesson. This run used one model only.

Does a lesson become a rule without a person?

By default, no: an owner, admin or approver accepts or rejects each lesson. An organization can turn on automatic acceptance for procedures and preferences that recur in 3 or more work items and cite a recorded failure or correction. In this run, the owner accepted the lesson before the next task started.

Why not put every lesson into every task?

Each lesson adds text to every task, and a rule for one folder can mislead work in another folder. A lesson tied to folders loads only when the work reaches those folders.

Where it lives in the product

  • Independent verifier

    The platform checks an AI worker's pull request in its own container, out of the worker's reach, and approves it only when a new test fails without the fix.

    Recorded walkthrough

  • Past decisions in the worker's context

    When a worker plans and acts, its context lists the matching accepted decisions, the owner's earlier choices and the accepted lessons, within a size limit, so the worker does not ask again.

  • Standalone autonomous AI employee

    A separate offering: one AI employee with its own private persistent computer and enrolled accounts that onboards itself, does a real engineering task alone and learns from owner corrections.

  • Procedures as scripts

    A tool sequence that succeeded on several finished items of one task class becomes a tested template. A person approves its hash, it runs through the gateway, and it is demoted when it fails.

  • Rulebook mined from history

    Commits, PRs, reviews, tickets, tests, CI and code are mined into rule candidates with evidence and scope. Accepted rules become checks, tested first against past changes. A rule that catches nothing in 90 days goes to its author to retire or keep.

  • Learning from the person's own AI history

    A person imports their own transcripts, files, commits and messages. Traits they accept steer briefs, checks and voice. History they bind to one repository becomes facts, decisions and documents that they confirm.

Turn the numbers into shipped work.

Crewshal runs these choices for you: a persistent AI worker with memory and rules, on your Claude and Codex subscriptions.