Multi-Turn Screenshot Debugging: Keeping Image Context Across Turns

Why Multi-Turn Screenshot Debugging Gets Expensive

Debugging with screenshots often spans several turns. You share an error screenshot, get analysis, then share another after a fix. But each new image you send adds to the conversation context—and on most APIs, including those accessed via aggregators, images consume tokens and are billed. On a pay-as-you-go platform with a ×1.3 markup on official prices, every image increases cost. Understanding how to manage image context can keep your debugging sessions efficient.

Re-sending vs. Referencing Images

When you continue a debugging conversation, you have two main options for images:

• Re-sending the image: Attach the same or updated screenshot in each new message. This ensures the model sees the image in the current turn but re-bills the image tokens every time.
• Referencing a prior image: In some interfaces or APIs, you can refer to an image already in the conversation history. The model can access it without you re-uploading, but the tokens still remain in the context window.

Each approach has trade-offs. Re-sending is straightforward but costly across many turns. Referencing saves on upload but still consumes context tokens because the image remains part of the conversation.

How Image Tokens Grow in a Conversation

Images are tokenized differently from text. A high-resolution screenshot can consume hundreds or thousands of tokens. In a multi-turn chat, the entire conversation—including all previous images—is sent to the model with each new request. So if you share three screenshots over five turns, by the fifth turn you're paying for all three images again (plus text). Token usage grows linearly with the number of images and turns.

Example of Token Growth

Suppose each image costs 500 tokens. Turn 1: 500 tokens for image + text. Turn 2: previous 500 + new 500 = 1000 tokens for images alone. Turn 3: 1500 tokens. The cost multiplies quickly. On a ×1.3 rate, that means you pay 1.3 times the official price for every token, including those re-sent images.

Billing on the ×1.3 Rate

On this platform, users pay the official API price multiplied by 1.3. That applies to all tokens—text and images. So if an image costs 500 tokens officially, you pay for 500 × 1.3 = 650 tokens' worth. When images are re-sent or kept in context, you pay that premium again and again. There's no discount for repeated images.

Key contributors who provide API keys earn credits at official price × 1.1 (or × 1.2 for premium models) in USDC. This is separate from the user cost.

Strategies to Keep Image Context Manageable

• Summarize instead of re-sending: After analyzing a screenshot, ask the model to summarize the relevant details in text. Then continue debugging with text only.
• Use crops: Send only the relevant portion of a screenshot to reduce token count.
• Limit turns with images: Once you've identified the issue, switch to text-based debugging for subsequent steps.
• Start fresh when possible: If the conversation history becomes too heavy, start a new chat and paste the text summary of previous findings.
• Batch updates: Instead of sending a new screenshot every turn, make several changes, then send one updated screenshot after a few steps.

When to Reference Prior Images

If your tool or API supports referencing images already in the conversation, use it when you need the model to compare a current state with a previous one. But remember: the model still processes those earlier images each turn, so token costs remain. Referencing avoids re-uploading but not re-billing.

Conclusion

Multi-turn screenshot debugging is powerful but can inflate token usage. By understanding how images are billed on the ×1.3 rate and how context grows, you can adopt habits that keep costs predictable. Prefer text summaries, crop images, and limit the number of turns with screenshots. This way, you get the benefits of visual debugging without unnecessary expense.