From Doodle to Charcoal Sketch: An AI Drawing Agent for reMarkable Tablets

When Doodles Meet AI Agents

For people who love creating but lack strong drawing skills, a stylus and a tablet rarely produce satisfying results. Recently, a developer shared a creative project on Reddit: an AI Agent that transforms rough doodles made on a reMarkable tablet into professional-quality charcoal sketches.

reMarkable is an e-paper tablet designed for writing and drawing, with its core appeal being a writing experience that closely mimics real paper. Unlike ordinary PDFs or images, reMarkable stores every stroke as vectorized pen-stroke data, recording pressure, speed, position, and other dimensions. This native format produces small file sizes, supports lossless scaling, and enables precise editing — making it a cornerstone of the device's ecosystem.

What makes this project especially noteworthy is that it outputs not a static image, but genuinely editable reMarkable native pen-stroke vector data. Users don't just receive a beautiful piece of artwork — they can edit it just like their own hand-drawn strokes.

"I'm not a great painter — so I made an agent that turns my doodles on my reMarkable into actually beautiful charcoal sketches." — Original author

The developer noted this was an iterative upgrade: early versions only returned static images, whereas the current version generates native device pen-stroke data, making the experience "so much better."

The Complete Pipeline: From Doodle to Sketch

The system uses a multi-agent collaboration + post-processing pipeline architecture with a clever workflow design. A Multi-Agent System breaks complex tasks into multiple specialized AI agents working in coordination — compared to a single large model handling everything, this design lets each agent focus on a single responsibility, making independent debugging and replacement easier, and preventing errors from cascading between stages. The core workflow breaks down into five steps:

1. Doodle and Selection

The user draws a doodle on the reMarkable tablet, then selects the region to be processed, defining the input boundary for the AI's creative work.

2. Creative Brief Generation

The first agent parses a screenshot of the device, interprets the doodle's intent, and writes a "creative brief" — essentially "translating" the rough sketch into actionable creative instructions for the AI. This agent uses the Qwen model. Qwen is a large language model series developed by Alibaba Cloud, spanning multiple parameter scales from lightweight to flagship, with a multimodal version (Qwen-VL) that supports image understanding. Its API costs are relatively competitive against mainstream alternatives, and it performs well on combined image-parsing and text-generation tasks, making it increasingly popular among multi-agent workflow developers.

3. Charcoal Art Image Generation

The second agent receives the creative brief and the original sketch, then generates a charcoal-style artistic image. Image generation uses the Nano-Banana-Lite model, while Qwen continues as a "QA" reviewer to ensure the generated result meets the creative brief.

4. Multi-Layer Vectorization Post-Processing

This is the most technically sophisticated stage of the project. Vectorization is the process of converting a bitmap (pixel image) into vector graphics described by mathematical curves. Traditional vectorization tools typically extract only a single-layer outline, but the texture of a charcoal sketch comes from layering multiple tonal values. The post-processing pipeline performs multi-layer vectorization on the generated image, separately extracting:

• Line work
• Shading
• Highlights

By vectorizing each layer separately to capture stroke characteristics across different tonal ranges, the pipeline reproduces the layered depth and texture of a charcoal sketch far more accurately than simply tracing the entire image in one pass.

5. Conversion to Native Strokes and Injection

All vector data is converted into reMarkable native pen-stroke data, injected into the clipboard, and pasted back onto the tablet, replacing the original doodle. The entire process feels "like magic," and a single undo step restores the original sketch.

Three Engineering Highlights

From an engineering perspective, this project demonstrates several design ideas worth borrowing in modern AI application development.

Multi-agent division of labor is the central highlight. Rather than asking a single large model to handle everything, the author has Qwen handle "understanding and quality control" while Nano-Banana-Lite handles "generation" — each doing what it does best. Popular orchestration frameworks like LangGraph, AutoGen, and CrewAI all support this kind of multi-agent design. This architecture improves output quality while keeping each stage controllable and easy to debug.

Built-in QA and retry logic is especially critical. Unstable outputs from generative AI are a persistent challenge. The Generate-Evaluate-Retry loop is a practical pattern for addressing this: an independent evaluation model scores or judges whether each output meets the original brief, triggering a retry if it falls short, with a maximum retry count to control cost and latency. The author has Qwen review each generated result and allows up to 3 retries — if all three attempts fall short, Qwen returns the version it deems the closest match. This pattern is already widely used in code generation, document writing, and other agent scenarios, and is a proven approach for improving agent reliability.

Transparent cost control. The author published API cost data: approximately $0.04 per generation, with a maximum cost of around $0.12 per image across up to 3 attempts — quite economical for a personal creative tool.

The Real Value: From Static Image to Editable Vector

The most easily overlooked — yet most valuable — breakthrough in this project is the shift in output format.

Most AI drawing tools stop at generating a static image: you can admire it, but editing it is difficult. This agent, by contrast, outputs reMarkable native pen strokes that are fundamentally no different from strokes you drew yourself: they can be erased, layered over, and built upon.

This effectively redefines the boundaries of "AI-assisted creation." AI is no longer a black box that "completes the work for you" — it becomes a reversible, editable, and collaborative step within the creative process. Users always remain in creative control. A single undo returns to the starting point, a design choice that significantly lowers the psychological barrier to using AI.

Takeaways for Creators and Developers

For everyday creators, tools like this lower the barrier to artistic expression. You don't need refined drawing skills — just a rough idea and a quick doodle, and the AI can help you realize it as a proper piece of artwork that remains editable.

For AI application developers, this project is an excellent sample of agent design for a vertical use case: clearly defined inputs and outputs, multi-agent division of labor, built-in QA and retry logic, and deep adaptation to the target device's native format. Rather than pursuing breadth, it pushes a specific need to an exceptional level of polish. This "narrow but deep" design philosophy is especially worth emulating at a time when AI applications are increasingly undifferentiated.

It's worth noting that this article is based on a developer's self-reported account from a single Reddit source. The project's real-world stability and performance on complex doodles remain to be validated by a wider user base. Regardless, it showcases the exciting potential of AI Agents in the realm of personal creative tools.