DomAgent: Autonomous DOM Agent Systems

• DomAgent is a family of autonomous software agents that interact with and reason over DOM structures using domain-specific knowledge extraction and affordance modeling.
• These agents employ dual retrieval strategies—integrating top-down knowledge graphs with bottom-up case-based reasoning—to drive efficient code generation and UI automation.
• Empirical evaluations demonstrate that DomAgent systems significantly improve accuracy and latency in both code generation and web UI tasks, highlighting their practical impact.

DomAgent refers to a family of autonomous software agent architectures designed to interact with, reason over, and operate on Document Object Model (DOM) or domain-specific structured environments. These agents leverage domain-specific knowledge acquisition, compact state representations, task-driven affordance extraction, and advanced retrieval or reasoning to enable robust automation and code generation across a range of digital tasks. Notable research contributions include the “DomAgent” framework for domain-specific code generation via knowledge-graph and case-based reasoning (Wang et al., 22 Mar 2026); DOM-based UI agents that use curated metadata and action registries (Ma et al., 16 Feb 2026); and patterns for constructing agent world models from raw structured data (Gidey et al., 28 Oct 2025).

1. Architectural Paradigms

DomAgent systems exhibit diverse but convergent architectural themes. The “DomAgent” for code generation (Wang et al., 22 Mar 2026) consists of three decoupled modules: (1) case base construction (extracting a representative, high-coverage set of code examples); (2) DomRetriever (a unifying retrieval system with both top-down knowledge graph (KG) and bottom-up case-based reasoning); and (3) a code generation agent (prompted with refined domain knowledge and representative cases). This modular decoupling enables flexible deployment: DomRetriever can augment any LLM with domain-specific context.

For DOM-based web automation, as exemplified by the EmbeWebAgent instantiation (Ma et al., 16 Feb 2026), the architecture is stack-agnostic and employs a thin frontend shim to expose ARIA-labeled elements, URL state, and a per-page function registry to a backend orchestrator. The session state $s_t = (u_t, O_t, F(u_t), H_t)$, capturing URL, filtered observations, function set, and history, forms the backbone for agent reasoning and planning.

Architectures that explicitly model affordances extract compact, task-relevant representations from verbose DOM trees (the DOM Transduction Pattern) and discover additional action capability at runtime from standardized service descriptions (the Hypermedia Affordances Recognition Pattern) (Gidey et al., 28 Oct 2025). This pattern emphasizes a pipeline: from raw DOM to a Page Affordance Model (PAM), with further runtime discovery enriching a persistent cognitive map.

2. Knowledge Representation and World Modeling

Effective DomAgents minimize computational overhead by distilling the DOM or domain knowledge into compressed, actionable representations. In web automation, curated ARIA annotations and developer-tagged function registries filter the observation space to task-relevant tokens, suppressing superfluous layout or boilerplate HTML (Ma et al., 16 Feb 2026). The formal encoding:

$$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$

is combined with session metadata to form backend embeddings for LLMs.

In world-modeling contexts, the DOM Transduction Pattern (Gidey et al., 28 Oct 2025) defines a selection function:

$M = Transduce(T; task, \tau, k)$

where the agent, for a task embedding, selects only those DOM nodes with representation similarity exceeding threshold $\tau$, returning the top-$k$ blocks for downstream planning. Token counts are reduced by 80–90% (e.g., a DOM of 12,300 tokens is compressed to 1,450 tokens), with proportional reduction in LLM inference latency.

For code generation, domain KGs are structured as

$$\mathcal{G} = \{\langle e, r, e'\rangle | e,e'\in \mathcal{E}, r\in \mathcal{R}\}$$

representing packages, functions, parameters, and their relationships, with each node and code case embedded for semantic retrieval (Wang et al., 22 Mar 2026).

3. Retrieval and Reasoning Mechanisms

A defining feature of advanced DomAgents is dual-mode retrieval integrating top-down (symbolic, KG-based) and bottom-up (case-based, experiential) reasoning. The DomRetriever (Wang et al., 22 Mar 2026) executes:

• Top-down: For each package $p_i$ in the KG, relevance for the input task $q$ is classified (via an LLM), followed by cosine-similarity retrieval of relevant nodes.
• Bottom-up: Natural language case descriptions are embedded and scored for similarity to the task, producing a ranked shortlist, with tie-breaking via package-overlap.
• Iterative refinement: An LLM orchestrates retrieval via explicit tool tokens (e.g., <search_kg>, <search_case>) within a chain-of-thought, continuing until convergence.

Formally, given $q$, KG $\mathcal{G}$, and case base $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$0, refined knowledge $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$1 and exemplary case $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$2 are selected for downstream prompting. Stopping occurs upon exhaustion of <search_* > tokens or an iteration cap.

In web UIs, a ReAct loop over the function registry $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$3 and observations $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$4 selects actions $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$5, with a prompt-driven next-action selection (Ma et al., 16 Feb 2026).

4. Action Primitives, Affordances, and Workflow

DomAgent environments define atomic and composite actions reflecting environment affordances.

• On web UIs, primitives include click, type, scroll, select, and navigate, with composite actions orchestrated by chaining or higher-level RPCs (Ma et al., 16 Feb 2026).
• For domain code generation, code cases are stored in a vector database and all run at ingestion to ensure validity (Wang et al., 22 Mar 2026).
• Affordance modeling (Gidey et al., 28 Oct 2025) enables the agent to dynamically extend its available action set by parsing service descriptions (e.g., WoT TD, OpenAPI), introducing new nodes into the affordance graph $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$6:

$$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$7

Tasks are planned via LLM-driven reasoning over pruned action spaces and affordance-enhanced cognitive maps.

5. Empirical Performance and Evaluation

DomAgent-based architectures have demonstrated significant performance improvements across benchmarks and domains.

• On DS-1000 (data science task benchmark), Qwen2.5-7B with DomAgent achieves pass@1 = 39.2% (vanilla model: 29.3%), LLaMA3.1-8B+DomAgent reaches 40.5% (vanilla: 30.4%), and augmentation of GPT-4o with DomRetriever yields 58.6% (vanilla: 51.0%) (Wang et al., 22 Mar 2026).
• In real-world proprietary environments (e.g., Volvo CAN-signal code generation), DomAgent achieves >96% pass@1, closing much of the gap between small open-source and large commercial LLMs.
• UI automation case studies (Ma et al., 16 Feb 2026) report end-to-end workflow success rates of 95% over 200 simulated sessions, with average round-trip action latency of 80 ms ($$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$8 ms, $$O_t = \{ o_{t,1}, \ldots, o_{t,N} \};\quad o_{t,i} = \phi(tag_i, role_i, label_i) \in \mathbb{R}^d$$9 sessions with <10% degradation under load). Compared to screenshot-based and raw-DOM scraper baselines, ARIA-grounded DomAgents cut error rates by approximately 50%.
• For DOM world modeling, token count and inference latency reductions (3–4$M = Transduce(T; task, \tau, k)$0) enable interactive LLM-based automation (Gidey et al., 28 Oct 2025).

6. Limitations and Prospects

Current DomAgent implementations require manual curation of function registries, ARIA labeling, and construction of high-coverage domain KGs and code case bases (Ma et al., 16 Feb 2026, Wang et al., 22 Mar 2026). These processes present maintenance and scalability challenges, particularly if the underlying environment evolves or metadata grows stale. Black-box learning from mistakes is not typically built in, though online fine-tuning or semi-automated function schema extraction are proposed directions. Function-level retrieval imposes granularity limits; the authors of (Wang et al., 22 Mar 2026) propose AST-based retrieval and soft-prompt augmentation as future improvements.

A plausible implication is that advances in automated domain knowledge extraction, formal environment introspection, and transfer between web and code domains will further extend the autonomy, reliability, and generality of DomAgent systems.

7. Standardization and Extension

Several authors outline paths toward interface and protocol standardization. Planned work includes standardized ARIA linting, zero-touch function registry generation from source code, and a common DomAgent protocol to facilitate reusable agents across multiple applications (Ma et al., 16 Feb 2026). Dynamic affordance discovery via semantic web service descriptions supports interoperable, adaptive agents that can integrate new resources and capabilities at runtime without hard-coded integration (Gidey et al., 28 Oct 2025). This suggests an ongoing trajectory toward fully decoupled, extensible cognitive and action architectures for autonomous agent systems.