Image-Only Page Triage and Routing Prompt Template

This prompt is designed for a single, critical job inside a document ingestion router: classifying a page that has already been flagged as containing zero extractable text characters. The OCR engine has returned an empty string, and the system must decide what to do next. The prompt's job is not to describe the image in freeform prose but to produce a structured routing decision. It must classify the image type (e.g., photograph, chart, blank page, corrupted scan), extract any content hints visible in the visual features (such as chart titles, axis labels, or handwritten notes), and recommend a processing path—such as sending the page to a specialized diagram extractor, flagging it for human review, or discarding it as a blank separator page. The ideal user is an ingestion pipeline engineer who needs a deterministic, testable classification step before downstream extraction.

Use this prompt only when two preconditions are met: the page has been confirmed to have zero extractable text by the OCR engine, and a multimodal model with vision capabilities is available for the classification call. Do not use this prompt as a general-purpose image describer or for pages that contain even a small amount of machine-readable text—those pages should follow the standard text extraction path. The prompt assumes the image is passed as a base64-encoded data URL or a cloud storage reference that the model can access. It also assumes that the routing taxonomy (the list of valid image types and processing paths) is defined by your pipeline architecture and supplied via the [ROUTING_TAXONOMY] placeholder. Without a clear taxonomy, the model will invent categories that don't map to your downstream handlers.

The primary failure mode to avoid is misrouting a page that actually contains text but was missed by OCR—for example, a page with white text on a dark background or very small font sizes. The prompt must include explicit instructions to check for any text-like visual features and to flag pages where text may be present but unreadable by the OCR engine. A secondary failure mode is treating every image-only page as requiring expensive human review; the prompt should distinguish between blank pages (which can be safely discarded), standard image types (which can be routed to automated processors), and genuinely ambiguous cases (which should be queued for human review). Before deploying, test the prompt against a golden set of known image-only pages including blank pages, photographs, charts, diagrams, corrupted scans, and pages with hidden or unusual text rendering.

The following template is designed to be dropped into an ingestion router that encounters pages with no extractable text. It forces the model to reason about visual features, classify the page type, and recommend a concrete downstream action. The square-bracket placeholders let you adapt the prompt to your specific document domain, risk tolerance, and available processing paths without rewriting the core logic.

textCopy
You are a document ingestion router. You receive pages that contain no extractable text. Your job is to classify the page, describe what you see, and recommend a processing path.

## INPUT
[IMAGE_PAGE]

## CONTEXT
Document type: [DOCUMENT_TYPE]
Expected content domain: [DOMAIN]
Available processing paths: [PROCESSING_PATHS]

## INSTRUCTIONS
1. Determine if the page is truly blank or contains visual content.
2. If the page contains visual content, classify it into one of the following types:
   - photograph
   - chart_or_graph
   - diagram_or_schematic
   - scanned_text_as_image
   - handwritten_content
   - form_with_handwriting
   - stamp_seal_or_watermark
   - other_visual_content
3. For non-blank pages, provide a brief content hint describing what you see (1-2 sentences).
4. Recommend a processing path from the available list. If none fit, recommend "human_review".
5. Assign a confidence score from 0.0 to 1.0 for your classification.

## OUTPUT_SCHEMA
Return ONLY valid JSON with this structure:
{
  "is_blank": boolean,
  "classification": string | null,
  "content_hint": string | null,
  "recommended_path": string,
  "confidence": number,
  "flags": string[]
}

## CONSTRAINTS
- If is_blank is true, classification and content_hint must be null.
- If the page appears to contain text rendered as an image, set classification to "scanned_text_as_image" and add "requires_ocr" to flags.
- If you cannot determine the content with confidence above 0.5, set recommended_path to "human_review".
- Do not hallucinate text content from blurry or illegible regions.
- For pages with multiple content types, choose the dominant type and note secondary types in flags.

## EXAMPLES
[FEW_SHOT_EXAMPLES]

## RISK_LEVEL
[RISK_LEVEL]

To adapt this template, replace the placeholders with your specific context. [PROCESSING_PATHS] should list the actual downstream queues or pipelines available in your system, such as ["ocr_pipeline", "image_analysis", "human_review", "archive"]. [FEW_SHOT_EXAMPLES] should include 2-4 annotated examples showing correct classification and routing decisions for pages typical in your document corpus. [RISK_LEVEL] controls how conservative the routing should be: for high-risk domains like healthcare or legal, add explicit instructions to route any uncertain classification to human review and set a higher confidence threshold.

Before deploying, validate that the output JSON matches the schema exactly. Common failures include returning classification as an empty string instead of null for blank pages, or omitting the flags array. Add a post-processing validator that rejects malformed outputs and triggers a retry with the error message appended to the prompt. For high-stakes ingestion pipelines, log every routing decision with the page image, model response, and final processing path for audit and eval regression testing.

This prompt operates as a pre-extraction router inside a document processing pipeline. It receives a page image (or a reference to one) and returns a structured routing decision. The application layer is responsible for image delivery, output validation, and downstream dispatch. Do not send raw base64-encoded images inline unless your model and context window support it reliably; prefer passing a cloud storage URI or a pre-signed URL that the model's vision capabilities can access. The prompt expects a single page at a time. For multi-page documents, call this prompt once per page and aggregate the routing decisions before dispatching the document to the appropriate processing path.

Validation and retry logic is critical because misrouting a page can silently corrupt downstream extraction. After receiving the JSON response, validate that the routing_decision field matches one of your allowed enum values (e.g., ocr_pipeline, human_review, discard_blank, image_analysis). If the confidence score falls below your threshold (start with 0.7 and calibrate based on production data), route to human review. If the model returns malformed JSON, retry once with a repair prompt that includes the raw output and the expected schema. If the retry also fails, log the failure and route the page to a manual triage queue. For high-volume pipelines, implement a circuit breaker that halts automated routing if the error rate exceeds 5% in a rolling window.

Model selection matters for this task. Vision-capable models (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro) are required. Do not use text-only models for image triage. If cost is a concern, consider a two-tier approach: use a smaller, faster vision model for blank-page detection and obvious text-as-image classification, then escalate ambiguous pages to a more capable model. Logging should capture the page identifier, the model's routing decision, confidence score, detected image type, content hints, and the full prompt and response for audit. This log becomes essential when debugging misrouted documents or calibrating confidence thresholds.

Downstream dispatch should be implemented as a deterministic switch statement in your application code, not as another LLM call. Map each routing_decision value to a specific pipeline function: ocr_pipeline sends the page to your OCR engine, human_review places it in a review queue with the content hints attached, discard_blank removes the page from processing and logs the action, and image_analysis routes to a vision model for detailed extraction. Never trust the model's routing label to directly trigger destructive actions (like deletion) without application-layer confirmation. For pages classified as text_as_image, verify that the page truly contains no extractable text before routing to OCR; a common failure mode is the model misclassifying pages with embedded text layers as image-only.