Harness Hub
All papers

Injectra: Retrofitting Extensibility into Web-Based Desktop Applications

Qin Sun

Verdict: Incremental

The engineering is clean: a layered injection system with sensible target and result semantics, and the code is released. The evaluation, however, is a single injection-succeeded count on the 38 apps on one machine. That count is not broken down by access path, and one of the paths modifies the app bundle. There are no baselines and no measure of the quality of LLM-generated enhancements. The abstract's claims of generality and AI-driven extensibility are therefore not established.

  • Novelty

    2 out of 5
  • Rigor

    1 out of 5
  • Reproducibility

    3 out of 5
  • Relevance to harnesses

    2 out of 5

TL;DR

Injectra is a CLI and library that injects JS, HTML and CSS into Electron and Tauri desktop apps. It can attach to a running app, or it can place a bootstrap in a modified copy of the app before launch. On top of it sits an LLM tool: the user selects a UI element, describes a change, and the model writes the code. The only quantitative result is that injection succeeded on all 38 apps installed on one macOS machine. There are no baselines, and nothing measures whether LLM-generated code does what users asked.

Adversarial review by Harness Hub · Nov 19, 2026 · read full text (truncated) · Suggest a correction

Original abstract (authors’ text, select to expand)

Large language models can generate code based on natural language prompts, opening up new possibilities for users to customize software and extend its functionality. This paper proposes and implements Injectra, a general-purpose code injection and feature enhancement system for existing desktop clients, suitable for applications whose user interfaces are built using embedded browser engines (such as Electron) or system WebViews (such as Tauri). Injectra decouples the host integration logic from the upper-layer enhancement code. Combining both runtime integration and pre-launch bootstrap mechanisms, it injects JavaScript, HTML, and CSS into the application's internal Web runtime environment through a unified execution channel, thereby enabling modifications to interface rendering, adjustments to interactive behaviors, and client-side functionality extensions. The system uses a command-line interface (CLI) as a unified entry point, allowing external tools, AI agents, and MCP integration layers to reuse its injection and enhancement capabilities. We tested 38 desktop applications already installed on our macOS machine; code injection was successfully completed for all of them. We demonstrated the system's capability to extend functionality through various enhanced use cases and also successfully validated the Windows version. Based on Injectra, we further developed an LLM-powered enhancement tool driven by selection and annotation: users select interface objects within the original application and describe their modification requirements; the large language model then generates the enhancement code, which is injected, executed, and rendered by Injectra. The system's source code has now been released as open source: https://github.com/sqmw/injectra.

Authors’ note

31 pages, 4 figures, 4 tables. Source code: https://github.com/sqmw/injectra

Filed undermcpruntimeagentsllm

Summary

Injectra targets desktop clients whose UI runs in an embedded browser engine (Electron) or a system WebView (Tauri). It separates host integration from enhancement code. The main parts are: - **Host adapters** establish an execution channel by one of two paths. Runtime access attaches to a running app through a debugging interface or host bridge. A pre-launch bootstrap is placed in a "derived copy of the application" (Section 3.1.2). - **A Web Execution Contract** requires that code be evaluated in a context that can access the target page's DOM. Returned Promises are awaited, results come back as JSON, and exceptions are reported as errors. - **A shared in-page runtime** registers, updates and cleans up managed resources. - **Target, session and capability checks**: target references are scoped to a backend instance, and sessions declare which operations they support. - **Execution feedback** distinguishes three cases: not executed, executed, and undetermined. A CLI and library layer expose these capabilities to external tools, AI agents and MCP layers. On top of them, the author builds an LLM tool driven by selection and annotation. The abstract reports two results: - code injection succeeded on all 38 desktop apps installed on the author's macOS machine; - the Windows version was "successfully validated." The text provided is truncated at the start of Section 4.3. The implementation section, the evaluation, the per-app breakdown and any results for the LLM tool were not available for this review.

Key findings

  • The abstract reports that code injection was completed for all 38 desktop applications installed on the author's macOS machine. No per-app breakdown or access-path breakdown appears in the provided text.
  • The abstract states that the Windows version was "successfully validated." No Windows app count appears in the provided text.
  • The core layer defines only three things: target identity, session capabilities, and error types. DOM access and transport are delegated to the Web Execution Contract and the host adapters (Section 4.1).
  • Execution feedback separates not executed, executed, and undetermined. "Executed" does not mean the code succeeded. Undetermined operations are not retried automatically, to avoid repeated side effects (Section 3.2.5, G5).
  • Section 3.1.4 lists explicit non-goals: no security sandbox; no automatic re-injection after page navigation; no recovery across windows; no adaptation after app updates. Section 4.2 adds that frames and workers are not treated as targets.
  • Section 3.1.3 states that "completion of page execution" and "generation of code that satisfies the user's intent" are distinct criteria. The latter "requires evaluation specific to the enhancement task."

The paper at a glance

01User or agent callsthe CLI or library02Host adapterdiscovers the appand its pages(runtime debuginterface or host…03Verify targetownership, sessionbinding andcapabilities04Payload(JS/HTML/CSS)submitted throughthe Web ExecutionContract05Shared in-pageruntime registers,updates or cleansup managedresources06Result returned asJSON, error, orundetermined07Optional upperlayer: selectionand annotation,then LLM codegeneration, then…
  1. User or agent calls the CLI or library
  2. Host adapter discovers the app and its pages (runtime debug interface or host bridge, or pre-launch bootstrap in a derived app copy)
  3. Verify target ownership, session binding and capabilities
  4. Payload (JS/HTML/CSS) submitted through the Web Execution Contract
  5. Shared in-page runtime registers, updates or cleans up managed resources
  6. Result returned as JSON, error, or undetermined
  7. Optional upper layer: selection and annotation, then LLM code generation, then injection
Fig. 1 — How the paper works, step by step (arXiv:2611.20713).

Why it matters

For harness builders, the relevant part is the agent-facing execution surface. Injectra gives an agent a CLI, which can be wrapped in MCP, for running code inside the DOM of Electron and Tauri apps. These are the same kinds of chat clients, editors and note apps that people already use. That is a different route from pixel-based computer-use agents, which work from screenshots and simulated input. Several design choices are worth copying into any tool-execution layer: - target references scoped to a backend instance; - capability checks before execution; - an explicit undetermined result that is never retried automatically. The paper says nothing about agent loops, memory or evals. Its evaluation also leaves two questions open: how often LLM-generated enhancements do what was asked, and how fragile injection is across app updates and hardened builds. Read it as a systems note with released code, not as evidence that agents can reliably customize desktop software.

Issues (7)

  • High severity

    The headline claim, injection completed for all 38 apps, is a binary injection-succeeded count. It does not show that enhancements work, persist, or survive navigation or app updates. The sample is whatever happened to be installed on one machine, and the provided text does not list the apps, their frameworks, or the success criterion.

  • High severity

    The 100% figure is uninformative without a breakdown by access path. Section 3.1.2 describes the pre-launch path as preparing an entry point in a "derived copy of the application." Any app whose bundle can be rewritten will therefore accept injection by construction. That is not the same as attaching to an unmodified running app. Figure 1 also hedges with "provided the target application has an available entry point." The paper should report how many of the 38 apps needed the bootstrap path versus runtime attach.

  • High severity

    The full-text abstract states that "Experimental results demonstrate that Injectra possesses generalized, cross-application integration capabilities" and promotes the LLM tool. The provided text reports no task success rate, user study or failure analysis for LLM-generated enhancements. The paper's own Section 3.1.3 says such task-specific evaluation is required.

  • Medium severity

    There are no baselines or measurements: - Table 1 is explicitly a qualitative summary that "does not represent a paired performance evaluation." - Section 2.2.5 attributes higher computational overhead and interaction latency to Interface Quilt without measuring either system. - Figure 1's claimed reduction in integration effort is asserted, with no lines-of-code or time-to-integrate data.

  • Medium severity

    The provided text does not discuss three practical blockers: - code signing or notarization when an app copy is modified; - Electron builds that disable debugging entry points; - auto-update overwriting the bootstrap. Combined with the absence of automatic re-injection after navigation or updates (Section 3.1.4), sustained use is likely to be fragile.

  • Medium severity

    Injected scripts, including LLM-generated ones, run with whatever privileges the page has, and the paper says capability declarations are not a sandbox. For a tool exposed to agents through MCP, page content containing a prompt injection could lead to arbitrary script execution inside logged-in clients. The paper states the lack of a sandbox as a non-goal and does not analyze the risk.

  • Low severity

    The Windows result is reported only as "successfully validated," with no app count and no failures listed. There is no replication across machines or app versions.

Questions for the authors

  • Which 38 apps were tested, and how many were Electron versus Tauri or system WebView?
  • How many of the 38 apps succeeded through runtime attach, and how many needed the pre-launch bootstrap in a derived app copy?
  • What counted as 'injection completed': a verified DOM effect, or only an evaluation that returned without error?
  • For the selection-and-annotation LLM tool, on what fraction of tasks did the generated code meet the user's intent, on the first attempt and after iteration?
  • How does the derived-copy path interact with code signing, notarization and auto-update on macOS and Windows?
  • When Injectra is exposed to autonomous agents through MCP, what prevents page content containing a prompt injection from triggering script execution in sensitive apps?
  • How often do payloads break after a minor app update?

Related in the directory

Open-source projects

The paper names MCP integration layers as callers of Injectra's CLI.
Agent-facing page evaluation over the Chrome DevTools Protocol, which the paper cites as an execution mechanism; overlaps with Injectra's runtime-attach path for Electron apps.
Gives agents in-app access to Tauri WebView apps, one of Injectra's two target host classes.
Pixel-based desktop computer-use agent, the external, screenshot-driven route that the paper contrasts with internal DOM access.

Code2Video uses agent-authored 3D proxies to guide video generation, enabling explicit control over structure and dynamics. However, how to construct proxies and prompts for optimal downstream quality remains underexplored, as do the capabilities and limitations of this paradigm. Through controlled experiments and blinded human evaluation, we study proxy granularity, physics simulation, and prompting. The results reveal task-dependent trade-offs: coarse proxies favor natural motion, while medium-grained proxies favor consistency. Physics simulation and proxy-aligned prompting further improve average quality. Guided by these findings, we introduce Coda-DaVinci, a task-adaptive agentic framework for Code2Video generation that selects between proxy-guided and direct generation, adapts modeling granularity to each entity, and coordinates simulation with proxy-grounded prompting. Its multi-agent harness preserves scene assets and guides repairs through visual inspection and independent review. Experiments demonstrate leading instruction following on VTR and scene consistency on R2M, improved physical plausibility over direct generation, and higher visual realism than the compared Code2Video baselines. Long-video evaluations further show gains in event structure and consistency across successive interactions, while revealing limitations in transition stability and adherence to scene settings.

Yiyan Ji, Qixun Wang +11

Agents based on large language models (LLMs) can now delete files and send payments on behalf of their users. News media reports routinely describe failures of these agents (e.g., Replit's coding agent deleting a production database), but a report often only says what went wrong and rarely (in)validates the incident or finds its root cause. Incident catalogs collect these reports, and benchmarks record whether agents fail, but neither replicates an incident nor tests the cause its report might identify. In this paper, we present ROGUE-AI (Replication of Agentic Security Events: Audit and Investigation), a multi-agent framework that closes the above gap and rebuilds each reported incident offline together with a matched control that lacks only the blamed cause, and runs agents on both. Our results suggest that ROGUE-AI is able to reproduce the reported harm in 89% of its 108 attempted replications. Agents built on five current GPT, Claude, Gemini and DeepSeek models made the reported mistake in 18% to 33% of runs, against at most 1% without the blamed cause. Of the 72 incidents with real-world harm, 62 had no underlying attacker, and in these, agents did what their task asked for but missed an ordinary hazard, such as a database shared with the live site. Replications without an attacker caused more harm than replications of prompt injection for all five models. Defenses against prompt injection look for injected instructions, but these replications contain none. Further, a warning after each tool output that names the hazard and its consequence lowered harm for all five models, whereas a note of the same length that does not mention the hazard left most of the harm in place. Built from real incidents, the ROGUE-AI replications form a reusable audit framework that vendors can rerun before each new release.

Mengxiao Wang, Mahbub Alam +2

Pretrained language models (LMs) remain unreliable on exact multi-digit arithmetic without gradient fine-tuning or external tool interpreters. We introduce closed-form, zero-gradient circuit-grafting primitives that compile deterministic computation directly into pretrained LM weights using zero training examples and zero runtime hooks, while bounding per-layer normalization drift and preserving natural-language (NL) competence. Our construction combines three analytical mechanisms: (1) two-layer Mellin-GLU quadrature over bias-free SwiGLU/GeGLU layers, turning unknown per-token RMSNorm scaling into translation along a log-spaced gate grid ($>250\times$ dynamic range) with IEEE 754 error bounds; (2) cross-token scale cancellation via signed Chebyshev Indefinite-RoPE self-sink attention and memoryless SiLU-antisymmetric GatedDeltaNet shifts; and (3) axis-aligned width extension ($d \to d+K$) with $\sqrt{d/(d+K)}$ norm compensation, Base-1000 canonical BPE emission, and differential $(+254,-256)$ tied unembeddings. An automated 5-stage compiler synthesizes 4-8 digit signed $\{+,-,\times\}$ circuits in constant $\mathsf{TC}^0$ depth alongside 3-literal Boolean (100%, $N=1{,}728$; plus 42-layer Gemma 4 E4B audits) and 5-bit Majority/Parity (100%) circuits. On 6-digit arithmetic ($N=1{,}200$, BF16), IBM Granite 4.2 3B (1.07M-1.33M active non-zeros, $\le 0.036\%$) and Alibaba Qwen 3.5 4B (2.25M-2.39M non-zeros, $\le 0.057\%$) reach 99.17% and 100.00% ALU-prefix accuracy (100% with an FP32 sidecar) and 98%-100% mid-sentence resumption, outperforming 12.8K-sample LoRA (42.2% / 61.7%, 0% inline continuation). A factorized block-sparse sidecar holds A100 memory at 7.89 / 10.65 GiB (4.60 / 8.14 GiB under INT8/INT4 + FP32 sidecar) while passing all 14/14 pre-registered $>2$K-token Tango splits ($N=4{,}392$; 0/11,134 OOD triggers).

Tanmay Sah

The Harness Hub newsletter

New harness companies, projects, releases and the monthly State of Harness report, in your inbox.