docdancer-document-agent

name	docdancer-document-agent
title	DocDancer: Towards Agentic Document-Grounded Information Seeking
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2601.05163
keywords	["Document Question Answering","Agent Design","Information Seeking","Synthetic Data Generation"]
description	Build open-source agents for document question-answering by modeling DocQA as information-seeking with explicit tool utilization. DocDancer uses an exploration-then-synthesis pipeline to generate high-quality training data, addressing the scarcity that limits agent-based document understanding systems.

When to Use This Skill

• Document question-answering systems with limited training data
• Applications requiring tool-driven exploration (highlighting, extracting, reasoning)
• Long-document understanding where sequential processing is necessary
• Scenarios where synthetic data generation can reduce annotation costs
• Building open-source DocQA agents without proprietary models

When NOT to Use This Skill

• Single-turn simple fact lookup (standard retrieval sufficient)
• Applications with abundant labeled DocQA training data
• Systems with hard latency constraints (multi-step reasoning is slower)
• Short-document scenarios (tool exploration adds overhead)

Problem Summary

Existing document question-answering (DocQA) agents suffer from two critical limitations: (1) they lack effective tool utilization, relying on implicit understanding instead of explicit document exploration, and (2) they depend heavily on closed-source models, limiting accessibility and adaptability. The fundamental barrier is scarcity of high-quality training data for DocQA agents—annotation is expensive and difficult at scale.

Solution: Tool-Driven DocQA with Synthetic Data

Model DocQA as information-seeking with explicit tool integration, then generate synthetic training data through an exploration-then-synthesis pipeline.

class DocDancerAgent:
    def __init__(self, base_llm, document):
        self.llm = base_llm
        self.document = document
        self.interaction_history = []

    def answer_document_question(self, question):
        """Tool-driven exploration followed by answer synthesis"""

        # Phase 1: Exploration
        exploration_steps = self.explore_document(question)
        # exploration_steps = [
        #     {"action": "highlight", "text": "...", "rationale": "..."},
        #     {"action": "extract", "content": "...", "rationale": "..."},
        #     {"action": "reason", "inference": "...", "rationale": "..."}
        

        
        answer = .synthesize_answer(question, exploration_steps)

        .interaction_history.append({
            : question,
            : exploration_steps,
            : answer
        })

         answer

     ():
        
        steps = []
        context = 

         exploration_turn  (max_exploration_steps):
            
            tool_decision = .llm.generate()

            action = parse_tool_action(tool_decision)

             action == :
                

            
             action == :
                highlighted_text = .identify_relevant_sections(question, context)
                steps.append({
                    : ,
                    : highlighted_text,
                    : tool_decision
                })
             action == :
                extracted_content = .extract_key_information(question, context)
                steps.append({
                    : ,
                    : extracted_content,
                    : tool_decision
                })
             action == :
                inference = .llm.generate()
                steps.append({
                    : ,
                    : inference,
                    : tool_decision
                })

         steps

     ():
        
        synthesis_prompt = 
         .llm.generate(synthesis_prompt)