Work · Community report
Set up a feedback loop for your agent
Set up a feedback loop for your agent. Log thumbs-down reactions and corrections into a running sheet, then have the agent turn them into instructions and review its mistakes overnight.
What you can get
What it is
Feedback log and instruction set
A running log of your corrections turned into instructions the agent reviews and applies overnight, so recurring mistakes get addressed without you repeating yourself.
It came back right when
- Thumbs-down reactions with explanations are actually logged to the sheet.
- Logged corrections are turned into instructions, not just stored as notes.
- You periodically review the growing instruction set rather than letting it run unchecked.
The checks are editorial, not from the source.
- Set up the logStops for your approval
A sheet or document the agent can write to.
- Define the reaction signal
A consistent way to flag a bad response.
- Explain each correction
A short note on what you expected instead.
- Review accumulated instructionsStops for your approval
You periodically check for conflicts or stale entries.
Editorial, not from the source
Works when
- You give responses a thumbs-down fairly often and want corrections to stick without repeating yourself.
- You're willing to write a short explanation each time, not just react.
- You're comfortable reviewing a growing log of instructions periodically.
Does not work when
- You want a one-time setup with no ongoing log review.
- You rarely give explicit feedback and expect behavior to improve without it.
- You need a guaranteed measurable improvement; this is one self-reported case with no before/after data.
Agent feedback loop: review template
| Item | What it is based on | Status |
|---|---|---|
| Feedback log | Sheet or document updated per reaction | [Verify] |
| Instruction conversion | Each logged explanation reviewed by you | [Review] |
| Accumulated instructions | Periodic check for conflicts or stale entries | [Review] |
The source case
On X, @nonieengel reports setting up a semi-automated feedback loop over a weekend: reacting with a thumbs-down and an explanation when unsatisfied, having Muse log the feedback and the explanation in a living Google Sheet, turn the corrections into instructions, and reflect on its mistakes overnight to adjust its behavior. This is one attributed report, checked on 2026-10-09: it does not say how the sheet-to-instruction step works technically, how many feedback entries were logged, or whether the agent's responses measurably improved afterward.
A public report by someone outside this library. Not independently reproduced here.
From the source
Source excerpt
Whenever I'm not satisfied with a response, I react with 👎 and explain what I expected. HUO (my muse) automatically collects the feedback in a living google sheet, turns my corrections into instructions, and reflects on his mistakes overnight to modify his behavior.
Quoted from the original posts. Not written by this guide, and not a result produced here.
Suggested prompt
Bring A sheet or document to act as the feedback log, Your explanation of what you expected, each time you react negatively. Acts Logs feedback and explanations to a sheet you control. Turns logged corrections into standing instructions for its own behavior. Reviews the log and adjusts overnight, on a schedule you set up. Source community report, checked 2026-10-09.
Written by this guide as a starting point, not quoted from the source. Your edits stay in this browser.
Other ways to ask
Editorial rewrites of the brief above, for a different emphasis. Copy them separately.
What you need
Editorial, not from the source
You supply
- A sheet or document to act as the feedback log
- Your explanation of what you expected, each time you react negatively
Connected
- Access to a Google Sheet or equivalent
Approved by you
- Your explanations are treated as the source of correction; the agent does not invent the fix
How to try it
Editorial, not from the source
- Set up a Google Sheet, or similar, to act as the living feedback log.
- Agree on a reaction, like a thumbs-down, that signals a response missed the mark.
- When you react, explain in a sentence or two what you expected instead; the explanation is what gets logged and turned into an instruction.
- Have it review the log overnight and turn each entry into an instruction for future behavior.
- Check in periodically on what instructions have accumulated, since the attributed report does not say how entries are reviewed or retired over time.
Pick a signal and a place to log it
A feedback loop needs two things to exist before anything else: a clear way to signal dissatisfaction, and somewhere that signal actually gets written down. In the attributed report, the signal was a thumbs-down reaction and the log was a living Google Sheet the agent updated automatically. You don't need that exact combination, but you do need something consistent, since an occasional complaint typed into a random chat is much harder to turn into a lasting instruction than a logged entry with a clear trigger. Set the sheet or document up first, confirm the agent can write to it, and only then start relying on the reaction to do the logging for you.
Write the explanation, not just the reaction
A thumbs-down alone tells the agent something was wrong, not what was wrong or what you wanted instead. The attributed report pairs every negative reaction with a short explanation, and that explanation is what actually becomes the instruction. Skipping the explanation and relying on the reaction alone leaves the agent guessing at the pattern behind your dissatisfaction, which is the opposite of what a feedback loop is for. Keep explanations specific and short rather than general: a note like be more concise in status updates is easier to turn into a lasting instruction than this wasn't quite right. The clearer the explanation, the less likely the resulting instruction is to be misapplied somewhere it doesn't belong.
Review what accumulates, don't just trust it
Once the loop runs for a while, the instruction set it produces keeps growing, and nothing in the attributed report describes what happens when two instructions start to conflict or when one stops being relevant. Build in your own periodic check, weekly or whenever it's convenient, to skim the accumulated instructions and remove ones that no longer apply. This also doubles as the closest thing to a progress check you'll get, since the source report doesn't include any measurement of whether responses actually improved after the setup; watching whether the same mistake keeps recurring is the practical substitute, and it's a habit worth keeping even once the loop feels like it's working well.
Open Muse to try it. That is the product's own site; this guide is not part of it.
Limits and confirmation points
Limits to confirm
- One attributed report, from a single weekend of setup. It does not describe the technical mechanism behind turning sheet entries into instructions.
- It does not say how many feedback entries were logged or whether responses measurably improved afterward.
- There is no description of what happens if feedback entries conflict with each other over time, or how old instructions are reviewed or removed.
- This is a self-reported personal setup, not a built-in product feature; expect to do some of the configuration yourself.
Stop and check
Editorial, not from the source
- Before setup: agree on the reaction signal and where feedback gets logged.
- Ongoing: write a real explanation each time you react negatively, since that explanation is the instruction source.
- Periodically: review the accumulated instructions for conflicts or ones that no longer apply.
If it goes wrong
Editorial, not from the source
- Feedback isn't getting logged consistently
- Check that the reaction and the sheet connection are both working; the attributed report does not detail the technical setup behind the logging.
- Old instructions conflict with new feedback
- Review the log yourself periodically and remove or update outdated entries; the source report doesn't describe an automatic conflict-resolution step.
- You can't tell if behavior is actually improving
- Keep your own informal record of repeat mistakes over a few weeks, since the attributed report gives no before/after measurement to compare against.
Common questions
Do I need Google Sheets specifically?
The attributed report used a Google Sheet, but any document or sheet the agent can write to and read from should work the same way. The sheet itself isn't the important part; a consistent log is.
What if I just react with a thumbs-down and don't explain?
The source report pairs every reaction with a written explanation, since that's what actually becomes the instruction. A reaction alone gives the agent nothing specific to correct.
How does logged feedback turn into an actual instruction?
The attributed report doesn't explain the technical mechanism behind this step. Expect to review and possibly rephrase how corrections are converted, rather than assuming it happens perfectly on its own.
Does this guarantee the agent gets better over time?
No. This is one self-reported setup with no before-and-after measurement included. Track whether repeat mistakes actually decrease yourself.
What happens if feedback entries contradict each other?
Not addressed in the source report. Review the accumulated instructions periodically yourself and resolve conflicts by updating or removing outdated entries.
Next
More in Work
Get recurring task recommendations — ask your own agent to check for relevant updates.