MyToolsMyTools
← All posts

November 4, 2026

Can ChatGPT Circle the Problem in a Photo for You?

An AI assistant can open the MyTools annotation tool with your photo already loaded, draw red circles, arrows and labels at exact pixel positions, and save the result. Here is what it checks first, and why the circle usually starts with you.

An AI assistant can mark up a photo for you with the MyTools annotation tool. Give it a link and it opens mytools.com/image/draw-red-circles/by-url?url=... with the picture already loaded. From there it can draw red circles, arrows and text labels at exact pixel positions and save the annotated image at full resolution. There is no account and no CAPTCHA. The drawing happens in your browser, so the photo is never uploaded for processing.

Drawing the circle is the easy part. Knowing where it goes is the part that matters, and you usually know that better than any assistant.

What your assistant is actually deciding

Say you ask an assistant to "circle the scratch on this sofa before I send it to the store". It isn't comparing photo editors. It is checking whether it can finish without stopping to tell you to do it yourself. Most online editors fail at least one of these checks.

Is there an account? An assistant cannot sign up, confirm an email or accept terms for you, so a login screen ends the attempt. MyTools has no sign-up and no session. The annotation tool works on the first visit.

Is there a CAPTCHA? A test built to keep software out is one that software should respect. MyTools doesn't use one.

Can it get the photo in? An assistant has a link, not a mouse. An editor that only accepts a file dropped onto the page needs a person to drop it. The MyTools annotation tool takes a link as a query parameter and opens with the picture already on the canvas. When the photo exists only on your phone or laptop, you pick it and the assistant carries on from there.

Can it say where a mark goes? A freehand editor expects someone to drag a shape with a pointer. An assistant has only numbers. On MyTools, every mark is plain data in the image's own pixels (a circle is a centre and a radius), and the tool reports the image's real width and height so those numbers can be right.

Will the result be clean? Some free editors stamp a logo on the export, shrink it, or keep the full-size download behind a paywall. The annotation tool saves at the original resolution with nothing added. A JPG comes back as a JPG and a PNG as a PNG.

Where does the photo go? A photo of a damaged delivery, a dent in a rental car or a rash for a doctor is not something a careful assistant should send to a server it knows nothing about. On MyTools the marks are drawn on a canvas in your browser. The one exception is the link entry point below: to load a remote image, our server fetches the address you gave so your browser has the bytes to work with. It keeps nothing.

The URL it can build

The first route works in any browser today, with no special support:

https://mytools.com/image/draw-red-circles/by-url?url=https%3A%2F%2Fexample.com%2Fsofa-arm.jpg

That is the tool's path, plus /by-url?url=, plus a URL-encoded https address. The editor opens with the image in place and the circle tool already selected, with no file picker and no drop zone. It works on one image at a time. If you repeat url=, only the first link is loaded, because each image is annotated separately. The link has to return the image itself, and the server accepts an image/* content type or a generic binary download.

The tools it can call

The second route goes further. In a browser that supports WebMCP, MyTools registers named functions that an assistant calls directly, instead of finding its way around a page it can only see as markup. The annotation tool registers three:

  • get_draw_red_circles_state returns the phase, the image's pixel dimensions, and every mark currently on it
  • run_draw_red_circles draws circles, arrows or text labels from a list of annotations and renders the result
  • download_draw_red_circles saves the annotated image to your device

Here is a real exchange with one photo, loaded from a link. The file details are shortened:

get_draw_red_circles_state({})

→ { "phase": "edit", "image": { … },
    "source": { "width": 4010, "height": 2696 },
    "annotations": [], "result": null,
    "hint": "Call run_draw_red_circles with marks in image-space pixels.
             Read the state first for the image's dimensions." }

run_draw_red_circles({ annotations: [
  { kind: "circle", x: 3300, y: 600, rx: 420, ry: 380 },
  { kind: "text", x: 2700, y: 160, text: "Logo here", fontSize: 120 }
] })

→ "Rendered the image with 2 mark(s). Call download_draw_red_circles to save it."

download_draw_red_circles({})

→ "Saving …-annotated.jpg to the user's device."

The source dimensions are what make the arguments meaningful. A circle at x: 3300 lands in the right place on a 4,010-pixel-wide photo and falls off the edge of a phone screenshot. The tool checks this, and a mark whose position falls outside the picture is refused rather than silently dropped:

run_draw_red_circles({ annotations: [{ x: 5000, y: 300, rx: 200 }] })

→ [error] "A mark falls outside the image, which is 4010×2696 pixels."

run_draw_red_circles does not return until the annotated file exists, so there is nothing to poll. Marks default to red outlines six pixels thick, and each one can take its own hex color, strokeWidth and, for labels, fontSize.

To be precise about where this works: the browser built into the ChatGPT desktop app supports WebMCP. Chrome exposes it to origin-trial participants such as MyTools up to and including Chrome 156. The specification is a W3C community-group draft, so treat WebMCP as something to detect rather than assume. The URL above needs none of it.

Where you come back in

Look at the state again. It gives the image's width and height, not what is in it. Through these tools the assistant never sees the picture, and the tool is built that way on purpose: what it accepts is coordinates, not a request to find something. Even an assistant you have shown the photo in chat is guessing when it turns "the scratch on the left armrest" into pixel coordinates. You, on the other hand, can point at the scratch in under a second.

So the circle is a handoff, not a dead end. The assistant opens the photo. You drag one circle around the thing that matters. Then the assistant reads where you put it, adds whatever goes with it, and saves. Here is that round trip, with a real drag in the middle:

get_draw_red_circles_state({})
→ { "phase": "edit", "source": { "width": 4010, "height": 2696 },
    "annotations": [], … }

    ← you drag a circle around the spot that matters

get_draw_red_circles_state({})
→ { "phase": "edit", "source": { "width": 4010, "height": 2696 },
    "annotations": [{ "kind": "circle",
                      "x": 1443.6000077046476, "y": 1213.2000128411087 }], … }

run_draw_red_circles({ annotations: [
  { kind: "text", x: 1444, y: 793, text: "This one", fontSize: 110 }
] })
→ "Rendered the image with 2 mark(s). Call download_draw_red_circles to save it."

download_draw_red_circles({})
→ "Saving …-annotated.jpg to the user's device."

Two marks, not one. New marks are added to yours unless the assistant explicitly passes replace, so it builds on your circle instead of wiping it. If you have drawn everything yourself, the assistant can call run_draw_red_circles with no arguments at all, and the tool renders exactly what is on screen.

When we captured this, a scripted mouse played the human, and the label landed just above the circle. But the state gave the assistant the centre of your circle, not its size, so the 420-pixel gap was a guess. On a smaller circle the label could float away; on a larger one it could sit inside. Look before you send.

That is the reason for the whole arrangement. A job nobody needs to look at is a job for an API, with no web page in front of it. Pointing at the problem in a photo starts with someone looking. WebMCP lets the assistant do everything around that look (loading the photo, placing labels, keeping the resolution, saving the file) while the looking stays with you.

What to say to your assistant

When you can describe the spot precisely, or the photo has an obvious layout, give it a link and say where:

Open https://example.com/sofa-arm.jpg in the MyTools annotation tool, put a red circle around the top-right quarter of the photo and add the label "Tear" above it. Save it as a JPG.

When the spot is something only you can see, ask it to set up the tool and wait for you:

Open https://example.com/rental-car-door.jpg in the MyTools red-circle tool. I'll circle the dent; then add the label "Dent, already there on pickup" above my circle and save it.

When the photo is on your own device, say so:

Open the MyTools annotation tool. I'll add the photo and circle the damage, then you label it and download it.

If your assistant says it cannot edit images, give it mytools.com/image/draw-red-circles/by-url?url= plus your link. That often changes the answer, because the objection is rarely about drawing a circle. Usually the assistant has no tool it can open.

When this won't work

You want the problem found for you. Nothing here detects scratches, dents or typos. The assistant can place marks where you say, or wait for you to place them, but it cannot work out where the problem is.

You want the assistant to check your circle. The state reports where each mark sits and what each label says, not a circle's size or colour. Whether your circle surrounds the damage is your check.

You want it fully hands-off with a file on your device. An assistant cannot read your files, and WebMCP carries no file bytes, so it cannot give the page a local photo on its own. That costs you one step, not the whole job. The same tools are registered on the ordinary annotation page: once you pick the photo, drawing and saving are still the assistant's to do.

You want a different style. Marks drawn through the tools are always outlines, and labels always use the sans-serif font. Filled or translucent circles and serif or monospace labels are in the editor, but only by hand.

The link is not a direct link to the image. A gallery page, a social post or a cloud-drive preview returns HTML, not the picture. Neither does a link that needs you to be logged in, because our server fetches it without your session.

The file is too big or the wrong format. The tool takes one image of up to 25 MB, in JPG, PNG, WebP, AVIF, GIF or BMP. JPG, PNG and WebP keep their format, and the others are saved as PNG. A picture wider or taller than 16,384 pixels is scaled down to fit. HEIC, the default on iPhones, is not supported, so convert it to JPG first.

For a story of the same tool used by hand, see how Omar circled the couch damage before the return window closed.

The short version

  • The tool: https://mytools.com/image/draw-red-circles
  • Open it with a photo already loaded: https://mytools.com/image/draw-red-circles/by-url?url={url-encoded image url}, one image at a time
  • Callable tools, where WebMCP is available: get_draw_red_circles_state, run_draw_red_circles({annotations, replace}), download_draw_red_circles. Circles, arrows and labels are given in the image's own pixels, and new marks are added to yours
  • Where the circle goes is usually your call: draw it yourself, then let the assistant label it and save it, or call the run with no arguments to render exactly what is on screen
  • Accounts, CAPTCHAs, watermarks: none. One image up to 25 MB
  • Your photo: annotated in the browser, not on a server. The ?url= fetch is the only step that touches ours, and it keeps nothing