Agent-Agnostic End-to-End C/C++ Application Performance Optimization

Opti-Agent-Bench: Benchmarking End-to-End Optimization R&D Agents on Real-World Business Problems

Opti-Agent-Bench is introduced, an end-to-end benchmark that evaluates Large Language Models across the complete optimization R&D pipeline, from understanding business-language descriptions through mathematical modeling, algorithm selection, and code implementation, to solution report generation.

Multi-agent Architecture for Legacy Custom Code Migration

Kozuchi Agent: A Language-Agnostic Open-Weight Agent for Software Repair

Industrial software-engineering teams increasingly need LLM agents that turn bug reports into correct patches, yet benchmark-scale operation adds long horizons, tool-use discipline, context persistence, heterogeneous clusters, and evaluation reuse. We present Kozuchi Agent, a language-agnostic open-weight repair agent and CI-operated evaluation pipeline. Explicit phases, persistent state, deterministic tools, a model-independent action interface, and cross-agent test-time selection make runs auditable and repeatable. With locally hosted Qwen3.5-27B, no fine-tuning, and TTS@8, Kozuchi resolves 374/500 SWE-bench Verified instances on the official evaluator. Unchanged on Multi-SWE-bench Java, the same 27-billion-parameter agent resolves 41/128 instances (32.03%), ranking first among strict open-weight submissions and fourth of 42 overall; on Python it ranks 12th of 135 and first among open-weight systems. Per-phase behavior remains within +/-5 percentage points across languages. Remaining failures mainly reflect semantic correctness, Java-specific harness issues, and selection errors. Across both tracks, results compare favorably with open/local peers by parameter count. Analysis of candidate diversity, selector regret, and patch reliability shows that the remaining gap is primarily semantic correctness and selection rather than edit formatting or proprietary-model access. Operationally, reusable CI stages reduce operator touch-points from five to one across heterogeneous internal clusters.

AgentExecutor: Partial Code Execution via Agentic Context Generation

This paper proposes AgentExecutor, a novel multi-agent framework for partial code execution that is Supported by the power of LLM agents who can think, act, and get feedback iteratively, and is able to autonomously explore a richer action space, enabling diverse operations such as creating resource files and resolving environment configuration.

BackendForge: Benchmarking Agentic End-to-End Code Generation with Backend Services

Large language models (LLMs) are increasingly used in agentic coding settings, where they can inspect files, execute commands, run tests, observe failures, and iteratively revise code. This shift raises a central evaluation question: can an agentic LLM generate an end-to-end software artifact that is both deployable and behaviorally correct under execution? Backend services provide a controlled but realistic substrate for this evaluation. Their APIs expose application-level executable semantics, and deployed behavior can be checked deterministically against an OpenAPI contract through black-box HTTP interactions. We introduce BackendForge, a benchmark of 56 contract-defined backend generation tasks rewritten from real open-source applications. Given a visible specification and an OpenAPI contract, an LLM must generate a Dockerized service that is built, deployed, and evaluated only through HTTP tests. To strengthen evaluation without introducing hidden requirements, BackendForge uses a test agent and a code agent to co-evolve the test oracle and reference service, where the test agent proposes specification-grounded backend tests and the code agent repairs the reference implementation. Although the best-performing model, GPT-5.5, succeeds on 55.4\% of tasks under the base oracle, it succeeds on only 28.6\% under the final oracle. This gap suggests that current LLMs can implement many local API behaviors, but still struggle to produce complete backend services.

Native Probes on Demand: Agent-Generated Reference Implementations for Layer-Bisection Debugging in Cross-Platform Apps

: Cross-platform application frameworks promise a single codebase for multiple operating systems, but pay for this with a stack of abstraction layers—application code, third-party packages, framework runtime, platform-specific bridges, and the underlying operating system or device. When a defect manifests at this stack’s surface, fault localization is hard precisely because each layer is a plausible suspect. We argue that agent-generated native reference implementations—small vertical prototypes built directly against the platform’s native APIs with the help of coding agents—make differential, layer-bisection debugging an economically viable default tactic in cross-platform development. The contribution of this position paper is threefold: a layered fault model that makes the localization problem explicit, the proposal of native probes on demand as a concrete debugging mechanism enabled by agentic code generation, and a discussion of the conditions under which the mechanism fails (cross-layer interactions, timing-dependent behavior, probe drift) together with a research agenda for controlled empirical evaluation. The position is that agent-assisted native probes shift the cost balance of cross-platform debugging in a way that is qualitatively new: a tactic that was previously reserved for teams with full multi-platform expertise becomes available, on demand, to single-stack developers.