TreeWriter: AI Hierarchical Authoring

• TreeWriter is an AI-driven hierarchical authoring environment that represents long-form documents as mutable tree structures integrating multi-level outlines and agentic AI support.
• It leverages context-sensitive GPT-based interventions and bi-directional outline–prose synchronization to enhance writing consistency and enable adaptive planning.
• Empirical evaluations showed improved AI helpfulness, creativity, and reduced cognitive load in complex scholarly and collaborative writing tasks.

TreeWriter is an AI-assisted hierarchical authoring environment designed to address the complex demands of generating, editing, and refining long-form documents. Unlike conventional linear co-writing tools, TreeWriter represents the document as a mutable tree structure, integrating multi-level outlining, version-controlled AI interventions, and context-sensitive agentic assistance. The system is architectured to facilitate sustained document consistency, adaptive planning, and iterative transformation from outline to prose, addressing the cognitive and workflow challenges inherent in scholarly, technical, and collaborative writing (Zhang et al., 19 Jan 2026).

1. Hierarchical Document Representation

TreeWriter encodes each document as a rooted tree $T = (V, E)$, where nodes $v \in V$ capture discrete textual or structural atoms and edges $E$ embody parent-child relationships. The root corresponds to the entire document. Each node encapsulates:

• $v.\text{id}$: unique node identifier,
• $v.\text{title}$: descriptive heading,
• $v.\text{content}$: editable rich text (supporting prose, bullet points, and hyperlinks),
• $v.\text{export}$ (optional): export block for linear output,
• $\text{parent}(v)$ and $\text{children}(v)$ references.

Non-leaf nodes generally store planning scaffolds, summaries, or multi-level outlines; leaf nodes contain final prose or paragraphs unless superseded by an export block. Document linearization is achieved by preorder traversal, with the linear output constructed as:

$$\text{LinearOutput} = \mathrm{concat}_{v \in P(T)} \, \text{Export}(v)$$

where $P(T)$ traverses nodes in sibling order, extracting $v.\text{export}$ if defined, otherwise a leaf's content.

Fundamental tree operations are exposed: node creation (addChild), deletion (removeNode), drag-and-drop reordering, “Split into subsections” (LLM-aided generation of children splitting $v.\text{content}$), summarization ("Generate outline from children"), and bi-directional drafting (synchronized outline↔paragraph generation).

2. AI Assistance and Contextual Management

AI-powered features span from atomic node edits to global restructuring, leveraging GPT-4.1 via Vercel AI SDK for editing buttons (split, summarize, generate paragraph/outline), and a GPT-5–based agentic chat assistant with tool integration. The agent operates over a constrained toolset:

• loadNodeContent, loadNodeChildren, suggestNewTitle, suggestNewContent, suggestNewChild, searchByKeyword.

Prompt construction is hierarchy-aware, injecting the selected node's title/content, its parent's outline, titles of siblings and children, plus optional search results. Prompts are templated to clarify tree logic: e.g., “parent summarizes children”, “children elaborate parent”, and instruct the agent to act via tools rather than open-ended generation. To stay within practical token constraints, only immediate relatives and searched nodes are included; large nodes can be decomposed via split or summarized to economize on context.

All AI edits invoke a diff viewer, where users accept or reject changes before content is overwritten; accepted revisions are versioned, supporting rollback and comparison. This supports DG3 (trustworthy, transparent AI collaboration).

3. User Interface and Authoring Workflow

The UI is organized into three columns:

• Tree Navigator (left): Collapsible hierarchical outline, toggling between Tree and Linear views, drag-and-drop reordering.
• Content Pane (middle): In Tree View, displays editable cards for child nodes of the current focus; in Linear View, shows the concatenated manuscript for the current subtree via preorder traversal. Navigation is synchronized: editing/exporting any section positions the user within the corresponding tree locus.
• AI Assistant & Buttons (right): Floating buttons trigger LLM-enabled actions for split, summarization, and paragraph generation. Each export block is independently actionable. The persistent chat assistant enables agentic support informed by local and contextual tree state.

Navigation includes a breadcrumb bar for ancestor jumping and focus synchronization between linearized and tree-based organization. Iterative editing flows enable propagation of outline changes downwards ("Revise children to match new outline") and upward summarization ("Generate outline from children"), thereby promoting outline–prose alignment (DG1, DG2).

4. Empirical Evaluation

Two empirical studies assessed TreeWriter:

Controlled Lab Study (N=12, within-subjects): Compared TreeWriter to Google Docs + Gemini across two tasks:

• Article modification (∼4,000 words, spanning expansion, nuance, summarization, reorganization, reframing, coherence),
• Creative writing from outline (∼800 words).

Metrics encompassed post-task Likert questionnaires (7-point scale) on AI helpfulness, section splitting, outline expansion, control, structural overview; the Creativity Support Index (CSI: Exploration, Expressiveness, Immersion, Enjoyment, Results-Worth-Effort); and NASA-TLX cognitive load.

Quantitative findings: TreeWriter outperformed the baseline across all seven dimensions (e.g., AI helpfulness 6.33 vs. 4.83; breaking sections 6.08 vs. 4.42; control 5.00 vs. 3.75). On creative writing, improvements remained statistically significant in Exploration (q=0.01), Creativity (q=0.033), and Idea Tracking (q=0.033). NASA-TLX indicated moderate reductions in cognitive load.

Qualitatively, the hierarchy aided navigation and mental modeling of large texts; the agentic assistant was effective for both fine-grained and global edits. Users reported a learning curve, excessive interface interaction for short documents, and occasional LLM hallucinations (Zhang et al., 19 Jan 2026).

Field Deployment (N=8; 2 months): In collaborative settings (25,000-word review, grant proposals), the tree structure facilitated division and assignment of writing responsibilities (Likert M=6.5/7), accelerated drafting from outlines, and improved brainstorming. Limitations included verbose AI output, indistinguishability of AI and human text, and workflow integration issues—specifically absent LaTeX equation handling, reference/figure management, and export to platforms like Zotero or Overleaf.

5. Design Principles and Limitations

TreeWriter’s design is informed by the following goals:

• DG1: Support for idea structuring and iterative drafting via multi-level outlines and bi-directional outline↔prose editing.
• DG2: Enforcement of sectional consistency through parent–child summarization, AI-driven propagation, and careful context scoping.
• DG3: Enabling trustworthy collaboration: AI actions are gated by user confirmation, with comprehensive versioning and clear scoping.

Additional recommendations include separation of conceptual scaffolding from final text (to avoid clutter and enable reasoning), progressive disclosure via tree navigation (to minimize cognitive overload), agentic interfaces constructed as explicit tool calls over the tree rather than blanket document generation, and enhanced interpretability by logging provenance of AI edits and outlines.

Key limitations are noted:

• Hierarchical interface complexity may be disproportionate for short or routine documents,
• Persistent LLM issues (hallucination, factual inaccuracy, inconsistent style) necessitate human oversight,
• Absent ecosystem integration (LaTeX, references, figures, academic export pipelines) impedes seamless adoption,
• Study scope is limited with respect to participant diversity and task breadth; broader, longitudinal assessment remains pending.

6. Implications and Research Directions

TreeWriter empirically demonstrates that tree-structured, hierarchy-first planning tightly coupled with agentic, context-limited AI support can improve idea exploration, structural transparency, and authorial control for long-form, especially collaborative, writing contexts (Zhang et al., 19 Jan 2026). The architectural and workflow patterns advanced by TreeWriter—bi-directional outline↔prose synchronization, tool-based agentic assistance, and modular context management—represent a fertile paradigm for future intelligent authoring environments.

A plausible implication is that large-scale document production in scientific and technical fields may increasingly rely on multi-level, tree-based scaffolds to enable granular AI/human interaction, version control, and content consistency. Operational and integration gaps around scholarly publishing workflows, reference/equation management, and AI reliability remain active challenges. Broader adoption and evaluation, especially for heterogeneous teams and extended projects, constitute central directions for future investigation.