By Jay Wang / Curify. These notes describe our internal retouching research and workflow development through November 12, 2026. They do not establish a production-quality autonomous retoucher. AI assisted with drafting; the observations below are grounded in our engineering records.
Our retouching pipeline could produce an image, pass technical checks, and still leave requested work unfinished.
In an October development audit, outputs that passed QA still included pending lighting work or no applied local repairs. We kept them marked as requiring review. The problem was not that the pipeline had secretly shipped them: it was that a green technical check answered a narrower question than “did we complete the edit?”
Successful execution, preservation, and task completion need separate evidence.
A request such as “reduce the shine, keep the skin texture, and leave the dress alone” contains several obligations: locate the issue, choose a scoped operation, apply an appropriate amount, and verify both the change and what should stay unchanged. A more attractive image can still fail that request.
That is why we are approaching the agent through three sources: before/after pairs, professional knowledge, and recordings of the editing process. Each answers a different question. None can replace checking the result against the brief.
1. Before/after pairs describe a destination, not the route
A pair can show the intended difference: a reduced color cast, a cleaner hair outline, or more even illumination. It rarely tells us which operation produced that difference—or which changes the client actually requested.
Before using a pair, we need to know whether the images show the same source frame, whether their geometry matches, and whether resizing, cropping, compression, or watermarks affect the comparison. We also need the edit brief. Otherwise, “be more like the after image” can encourage unrelated changes.
This distinction matters in our own collection. A reference useful for visual discussion is not automatically eligible for pixel-level evaluation. Multiple crops from one photograph are not independent examples. Images used to develop the workflow cannot later be presented as an unseen test set.
A useful record connects the images to the task:
{ "edit_intent": "reduce a localized highlight on the cheek", "preserve": ["skin texture", "expression", "jewelry", "dress detail"], "reference_role": "lighting direction, not identity replacement", "comparison_status": "requires alignment and region review" } This is an illustrative schema, not a client record or an implemented API contract.
We also compare against doing nothing. In one exposed development replay, the agent's average reference error was worse than the unchanged input. That does not settle every question about visual quality, but it prevents us from treating “the agent produced an image” as evidence of improvement.
2. Domain knowledge needs to become an executable decision
Professional advice often arrives as a short phrase: preserve texture, separate lighting from blemish repair, or avoid turning every white surface into the same neutral white.
An agent needs more than the phrase. It needs conditions for using a technique, a target region, an allowed strength, protected properties, and a way to decide whether the result helped.
Consider “brighten the skin slightly.” The face, hands, and another person in the photograph may require different treatment. Brightening a whole rectangle can also change hair, fabric, or reflected light. A numerical adjustment applied successfully does not establish that it was appropriate.
We therefore treat knowledge as a candidate editing policy that must be tested under a defined task. A proposed policy might separate illumination correction from local defect repair and require a texture check after either operation. It is a hypothesis until the comparison supports it.
The useful evaluation separates three questions:
| Question | What we inspect |
|---|---|
| Was the requested edit completed? | The defect or region named in the brief |
| Were protected details preserved? | Identity, product structure, texture, composition, and excluded regions |
| Does the user prefer this result? | A review against the same brief, allowing rejection of every candidate |
These are different outcomes. Passing a preservation check does not mean the blemish was removed. A user preferring a warmer look does not make a cooler expert reference the universal target.
3. Editing recordings expose decisions that pairs cannot
A screen recording can show tool selection, masks, operation order, diagnostic views, and changes of direction. It can explain why a retoucher worked on illumination before texture, or why a local adjustment was reduced after viewing the whole image.
But a recording is not a clean action trace. A cursor can move without changing pixels. A layer can be hidden. A diagnostic view can make the image look dramatically different without becoming part of the export. The recording can also begin after earlier edits have already happened.
In our tutorial review, an automatic transcript rendered a brush-opacity value as 15%, while the visible interface showed 5%. Later frames also showed additional texture work. Attributing the final image entirely to the earlier curves adjustment would have been incorrect.
That changed how we treat recordings: retain timestamps, inspect the actual interface, distinguish opacity from flow, and record what is visible versus what is inferred. A Photoshop brush setting is not automatically the correct parameter for a different editing tool.
Our current recording work includes sampled frames and transcript drafts. It is not complete reconstruction of professional actions, nor evidence that we trained a model to reproduce the workflow. Publicly viewable tutorials also do not automatically grant training or redistribution rights; no tutorial footage or client photographs are included here.
Connecting the three sources to an agent
The architecture we are working toward is:
Brief + reference role + protected details | Select an editing policy | Propose a scoped operation | Execute and retain a version | Check completion AND preservation | Accept, revise, revert, or request review Pairs help describe the intended outcome. Knowledge helps propose an operation. Recordings help explain sequencing and intermediate decisions. Verification determines whether that particular operation was useful on that particular image.
Here, “learning” primarily means improving the agent's planning, tool use, and evaluation workflow. We are not claiming that combining these resources has already trained new model weights or delivered a general improvement.
Our engineering records include local edits, protected regions, execution logs, and review states. The full policy-learning and feedback architecture is still a research direction. In particular, a pipeline stage marked “skipped” or “pending” must not silently count as completed work.
Two failure modes worth keeping in the evaluation
First, a metric can miss the edit. In an archived hair-edit review, some operations changed pixels entirely outside the frozen scoring region. An unchanged score therefore did not mean that nothing happened. The metric was uninformative about those hair changes. We kept the historical score and investigated the region coverage separately.
Second, a technically acceptable file can contain unfinished work. Our completion audit found outputs that passed technical checks but still had pending lighting work or no applied local repairs. They remained review-required. A valid file and preserved geometry are useful, but they are not a substitute for completing the brief.
A minimal review gate makes the distinction explicit:
# Illustrative review logic, not our production implementation. def review_status(technical_ok, task_checks, preservation_checks, pending): if not technical_ok: return "technical_failure" if pending or not task_checks or not preservation_checks: return "review_required" if any(check != "pass" for check in task_checks + preservation_checks): return "review_required" return "candidate_for_human_review" The brief must define the checks before execution. An empty checklist is missing evidence, not a pass. Skipped repairs remain pending; failed preservation checks require revision or rollback. Even the final state above is a candidate for review, not delivery approval.
These observations suggest a practical evaluation: compare the same inputs and budgets, record the first result and every revision, include failures in the denominator, and measure new damage as well as improvements. Independent visual review matters because a more elaborate verification loop can still agree with its own mistakes.
What we would test next
The next useful comparison is a general agent with tools, the same agent with a professional editing policy, and that policy with visual verification. Keep the inputs, tools, protected details, and total budget comparable.
We would report task completion, preservation regressions, human acceptance, and cost per accepted result separately. For repeated edits, feedback must refer to a specific image version: “return to this version and brighten the skin slightly” should not inherit changes from a rejected candidate.
The goal is an agent that can explain and check a small edit, then stop or ask for help when the evidence is insufficient. A polished before/after image is useful for showing an outcome. It is not, by itself, a record of how the outcome was obtained or whether the agent satisfied the request.
For a practical companion, our photo-retouching QA checklist covers agreeing scope and reviewing details before delivery. A separate batch product-image QA case describes targeted revisions in a 96-image production process; it is a production example, not a validation of this agent research.
About Curify
I'm building Curify, where we work on AI-assisted visual production and tools for creators and teams. Photo retouching is one part of that work: turning a brief into edits that can be reviewed, with clear limits on what changed and what remains uncertain. For a commercial batch, our product photo retouching service starts with representative images and an agreed scope.
How do you evaluate whether a requested edit succeeded without changing protected details? If you build editing agents, I would be especially interested in cases where your automated checks passed but a human reviewer still rejected the result.
