Harness Hub
All papers

Linglong Agent Service: A Runtime for Centralized Agent Reasoning and Distributed Execution

Hua Zhang, Min Jiang

Verdict: Incremental

This is an honestly scoped system description of an open-source runtime, with clear execution-site contracts and documented failure modes. It contains no measurements of any claimed benefit. Its competitor comparison rests on partial and partly historical documentation, and its security defaults are permissive. It adds design guidance, not evidence.

  • Novelty

    2 out of 5
  • Rigor

    1 out of 5
  • Reproducibility

    4 out of 5
  • Relevance to harnesses

    3 out of 5

TL;DR

A system description of a self-hosted Python agent service. The parent keeps model orchestration, tool descriptions and history. It forwards file, shell, terminal and MCP calls to one selected child machine over direct HTTP or a child-initiated WebSocket tunnel. A companion online_debugger lets an excepting Python process run inspection tools as client-side tool calls. The only evidence is self-authored regression test pass counts. There are no latency, task-success or repair measurements.

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

Original abstract (authors’ text, select to expand)

LLM agents can use remote tools and cloud sandboxes, but integrating reasoning, session state, and heterogeneous execution sites remains a runtime design problem. We present Linglong Agent Service (agentsvc), a self-hosted HTTP service and embeddable Python runtime that treats execution site as a configurable dimension alongside model, tools, and context. A parent service retains inference orchestration, tool descriptions, and conversation history; each inference request selects one child environment for file, shell, terminal, and MCP operations. Direct HTTP and child-initiated WebSocket tunnels carry the same application interfaces, including portable request context and centrally managed updates. The normal core path requires no third-party Python packages, with an optional Windows pseudo-terminal dependency. We further present online_debugger as the process-scale special case of execution-site separation: an instrumented program submits exception evidence, executes session-scoped inspection tools inside the incident process, and resumes the same diagnostic session. Its default prompt requires failing-then-passing reproduction evidence for source changes, while runtime patch activation and failed-call recovery remain unimplemented. We explain the design through constrained expected-utility reasoning, compare concrete mechanisms with Hermes Agent, Pi, Codex, and Claude Code, and report implementation and regression-test evidence. The current evidence establishes executable contracts, not performance advantages, repair accuracy, or production recovery. The source code is open source under the MIT license at https://github.com/mz24cn/agents.

Filed underorchestrationmcpsandboxruntimeagentsllm

Summary

agentsvc is a self-hosted HTTP service and embeddable Python runtime. - Its normal core path uses only the standard library. The scanned optional allow-list contains winpty for Windows pseudo-terminals. - It has four upstream adapters: OpenAI Chat Completions, OpenAI Responses, native Ollama chat and Anthropic Messages. - Execution site is a per-request field, `remote_env`. An omitted value means local execution, and an unknown value is rejected. The parent keeps the model-facing tool catalogue unchanged from local mode. It wraps execution tools so they forward to a child, which is another instance of the same service. Two transports exist: - direct HTTP; - a child-initiated WebSocket tunnel that replays method, path, headers and body against the child's local service. Portable request context travels in a base64url-encoded JSON header, X-Agents-Request-Context. The paper states this header is not encryption or authorization. Tunnel framing, timeouts, proxy support and credential handling are documented in detail. All the parameters are described as unmeasured engineering defaults. A client-side tool contract ends the current inference request and returns pending calls to the caller. The caller executes them and continues the same session. online_debugger builds on this contract. An instrumented Python program calls `report()` from an exception handler, then exposes six session-scoped tools (status, events, event, frame, threads, eval) to a coding agent that can also edit source. A default prompt asks for failing-then-passing reproduction evidence. Runtime patch activation and failed-call recovery (L5) are explicitly unimplemented. The design is justified with an expected-utility expression whose weights and probabilities are never estimated. The comparison with Hermes Agent, Pi, Codex and Claude Code is a documentation review only, with no same-task benchmark. Evidence is regression runs at commit 07d3d23a24f356bf2e59527b762ab66611c34f27, e.g. 'Full Python regression 1,969 passed' (Table 5). The authors state they have no latency benchmark, controlled repair study or evidence of general production recovery.

Key findings

  • The parent does not fetch the child's tool list on the main path. Tool names, schemas and descriptions stay identical between local and remote mode. Child compatibility is an operational obligation with no general schema negotiation, and a missing or incompatible child tool fails at call time (Section 3.2).
  • Routing authority is the per-request `remote_env` field. Session metadata only restores the UI selection. An API client that omits the field runs locally even if the session previously used a child (Section 4.1).
  • A forwarded workspace that does not exist on the child falls back to the child's default workspace, with only a warning recorded (Section 4.2).
  • Reverse tunnel defaults (Section 4.3): - binary body frames up to 256 KiB; - up to 16 in-flight HTTP calls per tunnel and eight local request workers; - bodies up to 8 MiB held in memory; - pings every 30 seconds and disconnect after 90 seconds without a frame; - 600-second forwarding timeout and 900 seconds for update pushes. The authors call these 'engineering defaults, not experimentally optimized parameters'.
  • Registration and online status do not probe local replay. A live control connection can coexist with a broken data plane, and parent forwarding timeouts do not by themselves cancel the child's operation (Section 4.4).
  • Client-side handoff ends the inference request, so the server's per-request `max_tool_rounds` (normally 200) cannot bound a handoff-driven debugger session. The driver's default budget of 80 handoffs does (Section 5.3).
  • online_debugger capture limits are 12 frames, 30 locals per frame and 200 characters per variable representation, with an LRU of up to 512 frame objects held by strong references. Entry limits do not bound memory in bytes. `debugger_eval` is 'enabled by default; not a sandbox' (Section 5.2, Table 2).
  • The L4 verification test checks only that the prompt contains the reproduction requirement. It does not check that the model follows it or that reproductions are adequate (Section 5.4).
  • Regression record (Table 5): - tunnel suite 56 passed; - debugger and client-tool suites 40 passed; - remote execution and remote orchestration suites 61 passed; - dependency and HTTPS suites 70 passed; - full Python regression 1,969 passed; - offline JavaScript self-check 31 passed. The targeted runs are subsets of the full suite.

The paper at a glance

01Client sends/v1/infer withremote_env andoptionalclient_tools02Parent runs themodel loop with itsown tool catalogueand history03Execution toolcalls are wrappedunder theiroriginalidentifiers and…04Forwarding usesdirect HTTP orreplay over achild-initiatedWebSocket tunnel05Child replaysagainst its localservice, rebuildinghost-bound statefrom the context…06Client-side toolcalls instead endthe request andreturn pendingcalls to the caller07Caller (e.g.online_debugger inthe incidentprocess) executesthe calls and…
  1. Client sends /v1/infer with remote_env and optional client_tools
  2. Parent runs the model loop with its own tool catalogue and history
  3. Execution tool calls are wrapped under their original identifiers and forwarded to the one selected child
  4. Forwarding uses direct HTTP or replay over a child-initiated WebSocket tunnel
  5. Child replays against its local service, rebuilding host-bound state from the context header
  6. Client-side tool calls instead end the request and return pending calls to the caller
  7. Caller (e.g. online_debugger in the incident process) executes the calls and resubmits with the same session ID
Fig. 1 — How the paper works, step by step (arXiv:2611.21129).

Why it matters

For harness builders, the value here is an explicit engineering contract, not a result. The paper spells out how to keep reasoning, tool schemas and history in one service while executing on a remote host behind NAT. It covers request-scoped site selection, identical tool schemas across sites, context propagation in a header, and reverse-tunnel framing and timeouts. It also documents failure modes that remote-execution harnesses commonly hit: - silent local execution when the site field is omitted; - workspace paths that silently fall back on the child; - control-plane health that hides a dead data plane; - forwarding timeouts that do not cancel child work; - handoff loops that escape per-request round limits. The client-side tool handoff applied to in-process exception inspection is a usable pattern for wiring a coding agent into application error handlers. However, its default arbitrary-eval tool and lack of per-tool admission make it unsafe to copy as-is. Nothing in the paper shows this design is faster, more reliable, cheaper to operate or better at repair than SSH-backed or sandbox-backed alternatives, and the authors say so. Read it as a design document with a pinned MIT-licensed implementation. It is not evidence for choosing this runtime over Codex, Claude Code, Pi or Hermes Agent.

Issues (7)

  • High severity

    There is no empirical evaluation. No latency, throughput, task success, repair accuracy or operational-cost numbers are reported. The only quantitative evidence is self-authored regression pass counts (e.g. 'Full Python regression 1,969 passed'), often run with controlled transports, under HYPOTHESIS_PROFILE=fast, on a single Linux and Python 3.13.11 environment. These show the code passes its own tests, not that the architecture delivers its claimed benefits (lower per-environment setup friction, coherent operator view). Contribution 1 still frames the design as reasoned 'under an explicit expected-utility criterion' whose weights and probabilities are never estimated, so the utility expression constrains nothing.

  • High severity

    Default security posture is unsafe for a runtime that lets a central model act on many machines and inside live processes: - `debugger_eval` runs model-generated expressions in the incident process and is enabled by default. It can call side-effecting functions, and locals can contain secrets with only truncation and a name blacklist as redaction. - There is no per-tool approval, sandbox or multi-tenant isolation. - If the service authentication gate is disabled, anyone who can reach the parent can register tunnels and operate children. - Loopback TLS replay disables certificate verification by default, so tunnel admission does not authenticate an unverified local TLS peer. The paper documents all of this, but documenting it does not make the defaults safe. Combined with prompt-level-only policies for database writes and restarts, this limits responsible deployment to trusted single-tenant setups.

  • Medium severity

    The competitor comparison is a documentation review with uneven coverage: - Hermes and Pi: mainly README material. - Codex: README and documentation index. - Claude Code: a 'retained system-prompt/tool-description snapshot dated May 9, 2026' that the authors call historical and non-reproducible. Most competitor cells in Table 4 read 'unverified', and the caption says 'Product claims require version-pinned official verification before submission'. The comparison therefore cannot support the 'strongest difference candidates' listed in Section 6.1. Hermes's documented SSH and sandbox terminal backends are not compared on the same tasks.

  • Medium severity

    Failure semantics on the debugger path permit duplicate side effects: - The accessory retries a transport-failed inference request once. - The paper states that deduplication and retry 'do not establish exactly-once processing across ambiguous network failure'. - `debugger_eval` can have side effects and is on by default. A retry can therefore re-execute side-effecting inspection in a production process. On the infrastructure path, forwarding timeouts do not cancel child operations, and a stalled response can retain a child worker. None of this has been measured.

  • Medium severity

    The framing overstates the debugger's scope. The keywords include 'self-healing' and the contributions claim 'exception-triggered diagnosis and source repair'. In practice: - L5 activation and recovery are unimplemented. - L4 reproduction is only a prompt instruction, verified by a test that asserts the prompt text exists. - L1 accuracy and L2 compliance are 'unmeasured' (Table 3). No repair outcome of any kind is reported.

  • Medium severity

    Silent fallbacks can cause actions on the wrong host or filesystem: - An omitted `remote_env` runs locally even for a session previously bound to a child. - A forwarded workspace missing on the child falls back to the child's default workspace with only a warning. The paper documents these behaviours but does not mitigate them. For harness builders they are correctness risks, not usability notes.

  • Low severity

    The manuscript is self-described as an 'English arXiv draft v0.1' and contains a pre-submission note in the Table 4 caption. The primary category is cs.RO (robotics), which does not match the content. Both points suggest an unfinished filing.

Questions for the authors

  • What is the measured per-call overhead of direct HTTP versus reverse WebSocket versus a CONNECT-proxied path versus SSH for the same deterministic tool calls, at concurrency 1, 8 and 16?
  • On a fixed set of injected defects, how often does online_debugger with captured locals and eval yield a correct root cause or patch compared with traceback-only input, as judged by independent hidden tests rather than agent-written reproductions?
  • Why are `debugger_eval` and unverified loopback TLS on by default, given that eval can call side-effecting functions in a production process and the single transport retry is not exactly-once?
  • Will the parent ever validate child tool schemas against its catalogue, or warn when a request for a previously remote session omits `remote_env`?
  • Can the Claude Code comparison be redone against current official documentation rather than a retained system-prompt snapshot?

Related in the directory

Open-source projects

One of the four systems compared mechanism by mechanism; cited for local, container, SSH and sandbox terminal backends.

Pi

Compared as a minimal extensible coding harness with RPC and SDK.
Compared; noted for documented sandbox and approval policies that agentsvc lacks.
Compared via a historical system-prompt snapshot; noted for permission mechanisms beyond service-level authentication.
agentsvc forwards MCP operations to child environments and implements MCP alongside execution placement.
The paper implements progressive skill disclosure and cites the Agent Skills specification.
Cited as related work on agent interfaces for repository-level software engineering.
Cited as the testable issue benchmark; the paper does not evaluate on it.

Commercial products

Cited as the source of Hermes Agent (Nous Research, 2026).
Cited as the source of Pi (earendil-works / badlogic, 2026).

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.