Can a model edit a photo it barely looks at?

01 · Where it came from

I edit photos for albums with Claude Code driving GIMP through MCP: a dark, rich street-snap look, light retouching, sometimes light that falls like afternoon sun. It works, eventually. Two things went wrong along the way. Requests like "let the sunlight come in naturally" came out like a spotlight. And a handful of photos used up a large share of my usage.

I measured one of those sessions, two days of editing in a single conversation:

• 1,808 model responses and over 500 GIMP calls (curves, color balance, hue and saturation, vignette, blur, and many raw API calls).
• 252 images returned into the conversation, mostly screenshots for checking the result.
• About 755 million input tokens read back from cache, plus about 2 million output tokens.
• The conversation read on each response grew from about 116,000 tokens on average in the first hour to about 695,000 on the last day.

The cost did not come from any single edit. It came from a conversation that kept growing, full of screenshots, and was read again on every response. Caching made each read cheap, but not cheap enough at that volume.

02 · Why it is hard

A language model sees an image as a few hundred to a couple of thousand tokens made from small patches. That is good for what is in the picture and where. It is weak at exact values: how bright, how warm, how much of the highlights is clipped. So the model adjusts by trial and error and checks each step by looking again, and every look costs tokens and stays in the conversation.

Some of the work cannot be reduced to numbers. Whether light looks natural, whether a face still looks like the person, whether a retouch shows: those need judgment, and for now that means an image.

03 · Approach

• An interface made for the model. The program is designed around how a language model reads and acts, not adapted from a screen made for people.
• Keep the state out of the conversation. The edit lives in a project file. The model does not re-read the whole history on each step.
• Measure instead of looking. After each step the tool reports numbers: brightness, contrast, black and white points, clipping, saturation, color temperature, sharpness, and the same inside and outside a selection. About a hundred tokens instead of a screenshot.
• Recipes instead of improvising. A look is a handful of parameters with a known effect. The model picks a recipe and adjusts a few values rather than assembling dozens of low-level calls.
• Look only when it matters. A small crop for judgments numbers cannot make, and one final check.
• A lighter interface. A command-line tool with a short guide instead of a large MCP tool list loaded into every conversation.

04 · How it will be judged

My taste is one person's taste, so it cannot be the measure. The method has to be judged on problems with answers:

• Reproducing expert edits. How close it gets to retouching done by professionals. A candidate is the MIT-Adobe FiveK dataset, 5,000 raw photos each edited by five experts; its research license still has to be checked for this use.
• Following instructions. How well it carries out requests like "warmer, light from the left, keep the highlights", judged blind.
• Cost per photo. Tokens per finished edit, against a model that checks with screenshots.

The target is to match the screenshot approach on quality at a small fraction of its cost.

05 · What already exists

• JarvisArt trains a multimodal model to drive more than 200 Lightroom tools. It looks at the image; this project tries to look as little as possible.
• Imagen AI offers a commercial API that learns a photographer's style and applies it to whole shoots.
• Code execution and CLI wrappers for MCP already cut the token cost of tool definitions and large results. They make each call cheaper but do not tell the model whether the edit worked.
• Generative image models can edit from a sentence, but they redraw the picture rather than adjust it, which is not what precise retouching needs.

06 · Status and who

Latent is a project of 7xz, a one-person studio in Korea, in early development: a measured baseline, design principles and a plan for evaluation. I build it with Claude Code.

Photo editing is the first case, not the whole plan. If the approach holds up there, the next step is to carry the same interface to other work where models now act through screenshots and wrapped tools: video color and editing first, then other visual programs. The aim is a common way for programs to talk to language models, proven one domain at a time.

It shares a question with Afterimage. Afterimage asks how a model takes in an input on the inside; Latent asks how far quality goes when the input is given as numbers and structure instead of pixels.

Contact: me@7xz.dev