ReAct Agentic Harness Framework

• ReAct Agentic Harness is a modular framework that decomposes tasks into distinct reasoning and acting modules to ensure targeted refinements and transparent workflow updates.
• It employs structured, JSON-based communication protocols to enforce scope constraints and maintain semantic fidelity in iterative processes like visual-report refinement.
• The architecture enhances LLM interactions by preserving contextual continuity and auditability, leading to improved precision in applications such as program repair and feature engineering.

A ReAct Agentic Harness is an advanced, modular orchestration framework that instantiates and governs ReAct-style (reasoning + action) agent loops, often partitioned into multiple specialized agents to maximize modularity, transparency, and targeted task control. Its formal objective is to robustly, efficiently, and transparently structure the interaction between LLMs, external tools, user interactions, and iterative feedback in complex workflows, such as semantic visual sensemaking, program repair, and feature engineering. A ReAct Agentic Harness typically combines the decomposition of agent roles (for example, separating reasoning from acting), structured communication protocols, enforced scope constraints, and fine-grained observability into a single, reusable pipeline, addressing deficiencies of vanilla single-loop ReAct architectures in continuity, explainability, and adaptation. Below is an in-depth analysis of its core principles, architecture, operational modalities, evaluation criteria, and representative applications, as exemplified in the VIS-ReAct system for visual-report refinement (Tang et al., 2 Oct 2025).

1. Concept and Motivation

In iterative AI workflows, such as interactive sensemaking, ReAct agentic harnesses were designed to overcome the limitations of monolithic LLM prompting where global regeneration of outputs leads to loss of contextual continuity, lack of transparency in updates, and poor interaction traceability. In classic ReAct, the LLM alternates between "Thought" (self-reflective reasoning) and "Action" (tool use or output modification), but the scope of edits and the mapping from user interactions to agentic modifications remain opaque and coarse-grained. The harness paradigm explicitly separates reasoning about user-provided semantic interactions (e.g., cluster highlights, notes) from executing targeted edits, ensuring only affected regions of the output change and all causal mappings remain auditable.

VIS-ReAct exemplifies this approach in sensemaking report refinement:

• The ReAct harness decomposes the refinement cycle into two agents—a reasoning (analysis) agent and an acting (refinement) agent—mediated by machine-interpretable plans that capture inferred user intent and planned changes (Tang et al., 2 Oct 2025).
• This separation institutes three foundational operational principles: P1 (targeted refinement), P2 (semantic fidelity), and P3 (transparent inference).

2. Architectural Decomposition and Process Flow

A canonical ReAct agentic harness comprises the following pipeline:

• Analysis Agent (Reasoning): Ingests the current workspace state, user-induced semantic interactions, and the prior report. It interprets the interactions, infers user intent, and emits a JSON-structured refinement plan with localized edit specifications.
  • Formally,

  $A_n = \mathrm{AnalysisAgent}(R_{n-1}, W_n, SI_n)$

  where $A_n.\mathit{plan}$ encodes the editing instructions.

• Refinement Agent (Acting): Receives the prior report, updated workspace, and refinement plan, executing only the specified changes. Unaffected text remains untouched, constraining the scope and maintaining report integrity.
  • Formally,

  $$R_n = \mathrm{RefinementAgent}(R_{n-1}, W_n, A_n.\mathit{plan})$$

The harness orchestrates iterations over $n=1..N$, extracting semantic interaction sets $SI_n$ by diffing workspace states $W_{n-1}$, $W_n$, then sequentially invoking the two agents as illustrated in the following pseudocode:

for n = 1 to N do SI_n ← extractSemanticInteractions(W_{n-1}, W_n) A_n ← AnalysisAgent(R_{n-1}, W_n, SI_n) R_n ← RefinementAgent(R_{n-1}, W_n, A_n.plan) end for

(Tang et al., 2 Oct 2025)

3. Semantic Interaction Encoding and Agent Communication

Effective harness operation requires precise encoding of user interactions:

• Each atomic interaction $si_t$ is encoded as a vector $$\mathbf{x}_t = [\,\mathit{type}_t,\,\mathit{cluster}_t,\,\mathit{span}_t,\,w_t\,] \in \mathbb{R}^d$$, with optional embeddings $\mathbf{e}_t$ used as auxiliary context.
• The harness maintains structured, machine-readable communication protocols (e.g., JSON) between reasoning and acting agents, enabling deterministic plan execution and explicit logging of intent-to-action mappings.

A typical plan output from the Analysis Agent adopts the following schema:

{ "intent": "...", "plan": [ { "paragraph_id": 2, "action": "append", "content": "Add detail about X." }, { "paragraph_id": 5, "action": "revise", "content": "Correct the timeline to reflect Y." } ] }

This structure ensures that planned edits are explicit, localized, and auditable, directly enforcing the harness principles of targeted change and semantic traceability.

4. Harness Principles: Targetedness, Fidelity, and Transparency

The agentic harness, exemplified by VIS-ReAct, operationalizes three core evaluation criteria:

• Targeted Refinement (P1): Only those output regions (paragraphs, sections) impacted by the user’s new semantic interactions are modified. Edits outside the planned scope are forbidden by explicit agent instructions and, optionally, by constrained generation hyperparameters (e.g., zero temperature).
  • Metrics: Compute precision/recall for correctly refined paragraphs, e.g.,

  $$\text{Precision} = \frac{N_{TPP}}{N_{PP}}, \quad \text{Recall} = \frac{N_{TPP}}{N_{TP}}$$

  where $N_{TPP}$ = true positive paragraphs, $N_{PP}$ = total changed, $N_{TP}$ = paragraphs that should change.

• Semantic Fidelity (P2): The refined output must faithfully and completely reflect the content signaled by user actions. Partial or hallucinated incorporation of changes is penalized.
  • Metrics: Precision/recall of sentence edits relevant to $SI$, e.g.,

  $$\text{Precision} = \frac{N_{TPS}}{N_S},\quad \text{Recall} = \frac{N_{RSI}}{N_{SI}}$$

  $N_{TPS}$ = relevant edited sentences, $N_S$ = total sentences edited, $N_{RSI}$ = realized semantic interactions, $N_{SI}$ = total $SI$.

• Transparent Inference (P3): The plan output and supporting reasoning (including chain-of-thought traces) must be human-inspectable, supporting verification, error analysis, and user trust. Plan logs provide an audit trail linking each interaction with its downstream textual realization.

In VIS-ReAct’s empirical evaluation, the harness demonstrated F1-scores of 0.887 (targeted refinement) and 0.614 (semantic fidelity), outperforming baseline strategies and naive SI-only approaches (Tang et al., 2 Oct 2025).

5. Prompt Engineering, Modularity, and Scope Constraints

Harness robustness is underwritten by several engineering and design techniques:

• Decoupling reasoning and acting: By modularizing these roles, the harness enables introspection/correction of intermediate products before execution. This separation is enforced at the prompt and interface level.
• Structured, enforceable output contracts: The reasoning agent outputs machine-parsable plans; the acting agent is explicitly forbidden to deviate from these instructions or modify unaffected regions.
• Context propagation: Both agents receive prior outputs and current workspace representations, ensuring that modifications remain coherent and contextually grounded.
• Scope constraints: The acting agent’s prompts and underlying execution logic bar modifications outside specified targets, preventing overreach and guaranteeing incrementalism.
• Transparency and logging: All agent outputs—intents, plans, edits—are logged for user validation and system debugging.

This modular architecture supports extensibility (e.g., new interaction types like drag-and-drop cluster reorganizations) without requiring overhaul of the underlying refinement engine.

6. Agentic Harnesses in the Context of Advanced Agentic Design

The ReAct Agentic Harness as detailed in VIS-ReAct reflects broader agentic system-theoretic trends:

• It is an instantiation of the modular, multi-agent designs advocated for robust agentic AI, in which functional decomposition, explicit memory, supervisory planning, and adaptation are central design patterns (Dao et al., 27 Jan 2026).
• Textual, structured inter-agent protocols (often JSON-based) and explicit separation of world-state modeling, planning, execution, and adaptation support improved observability, debugging, and system maintainability.
• The agentic harness provides a template for orchestration in various domains, not only sensemaking (as in VIS-ReAct), but also feature engineering, program repair, observability frameworks, and coverage-guided fuzzing, all of which are trending toward increasingly modular harness architectures where fine control, auditability, and explainability are paramount.

7. Applications and Generalization

The ReAct Agentic Harness is instantiated across domains with high impact:

• Interactive sensemaking report refinement: VIS-ReAct realizes agentic harness principles in dynamically updating narrative documents as users manipulate visual workspaces, showing significant improvement in targetedness and fidelity (Tang et al., 2 Oct 2025).
• Feature engineering: Agentic ReAct harnesses underlie recent advances in automated feature discovery and selection, where action plans, code evaluation, and error-checking are all separated into distinct agentic phases.
• Software repair and maintenance: Large-scale agentic program repair frameworks adopt ReAct harnesses pairing LLM reasoning, tool orchestration, and human-in-the-loop validation for efficient, robust correction of codebases.

Qualitative outcomes include improved user trust (transparent tracing of edits), higher performance metrics (precision, recall), and simpler extensibility for new actions and interaction modalities.

---

In conclusion, the ReAct Agentic Harness is a formalized, multi-agent orchestration structure that modularizes reasoning and acting phases, ensures explicit traceability between user interaction and output modification, and enforces strict scope and fidelity constraints. Its design is foundational for robust, transparent, and extensible LLM-driven workflows in complex, iterative environments (Tang et al., 2 Oct 2025).