Papers for

enterprise software engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Code methods improve accuracy and cut costs for AI outputs

COVE: A Task-Adaptive, Code-Based Ensemble for Proactive Verification of LLM Outputs

Abstract: Large Language Models (LLMs) are now embedded in enterprise workflows, yet their outputs remain prone to hallucinations: plausible-sounding but factually incorrect or malformed content. Most verification approaches are reactive, detecting errors only after generation and often spending additional expensive LLM calls to do so. We present COVE, a task-adaptive, code-based ensemble that takes the opposite stance: it prevents errors before generation and validates structure and consistency afterwards using six deterministic, pure-Python innovations that add no extra LLM calls. On an internal evaluation spanning 11 text datasets (1,020 examples) and 4 image datasets (200 examples), COVE lifts text accuracy from a 45.2% unverified baseline to 82.1% (an 81.7% relative improvement), improves image accuracy by 69.5%, and reduces token usage by 48 to 96% (simulated cost model), at a measured verification overhead of 0.26 ms per output (excluding the LLM call). This article describes the engineering design of each innovation (with pseudocode and the exact parameters we use), the measured impact, an ablation of every component, and the practical lessons learned from deploying code-based verification in enterprise pipelines.

Mon 2 NovSoftware Engineering
The gist
Large language models often make believable but incorrect or mixed-up responses, causing problems in work settings. The authors created COVE, a system that uses computer code to stop mistakes before they happen and check answers afterwards without extra expensive AI calls. Tested on many text and image examples, COVE greatly improved correctness and used much less computing effort. This approach shows how simple code can make AI answers more reliable and cheaper to produce.
Open → 2611.03111v1

Large language models improve business API calls with process knowledge

Grounding LLM Agents in Business Processes: Process-Aware Knowledge Graphs for Reliable Multi-Step Service Invocation

Abstract: Large language model (LLM) agents that call enterprise APIs must select the correct endpoints, follow process order, use valid payload keys, and choose coded values from predefined lists. However, current retrieval-augmented service discovery treats endpoints independently and therefore misses process and schema constraints. We address this limitation by integrating Open Data Protocol (OData) metadata and Business Process Model and Notation (BPMN) reference processes in a typed property graph. A hybrid retriever identifies candidate endpoints using dense embeddings and follows process edges to retrieve subsequent endpoints. We evaluate the method on 42 enterprise services with process-chain ground truth. For queries with low lexical overlap between the query and downstream entities, it improves Recall@3 by 5.7 points (n=74), with consistent gains across embedding models and cut-offs. It matches dense retrieval on other queries and provides no improvement on OpenAPI services without a process layer, indicating that the gains arise from process structure. We also evaluate an LLM agent on 81 multi-step queries. It completes 38.7% of tasks, compared with 10.3% for a chunk-based baseline. In an elicitation probe, providing valid code lists eliminates invented codes but leaves invalid keys in 46% of write runs. Full typed context reduces invalid calls to 3% (3 of 101 runs), with no invented codes. These results show that exposing process and schema constraints during retrieval improves the reliability of agent-driven API calls.

Tue 27 OctArtificial IntelligenceSoftware Engineering
The gist
Calling business software correctly is tricky because apps must follow specific steps and use exact keys and codes. The authors created a way to teach language models about these rules by linking business process maps and API details into a graph. This helps the models pick the right steps and data to call services reliably. Their tests show this method works better than older ones, especially on complicated multi-step tasks.
Open → 2610.37242v1

Erebots framework enables flexible AI conversation agents to work together

EREBOTS 4.0: A framework for conversational assistants with A2A agents and MCP tools

Abstract: In recent years, multi-agent systems have shifted from rule-based, symbolic agents to sub-symbolic agents built on language models. However, several limitations remain unresolved. The new frontier is neuro-symbolic agents, which pair language models with deterministic tools and explicit protocols. Without a common framework to standardize and compose them, each study rebuilds the same infrastructure, and results are hard to replicate. This paper presents EREBOTS 4.0, an open-source, hybrid-AI, multi-agent framework that fills this gap for conversational assistants. Language-model agents plan and route requests, while deterministic tools compute exact results over the Model Context Protocol (MCP). An orchestrator selects one or more specialist agents per turn and calls them over the Agent2Agent protocol (A2A). A new agent, local or remote, is added by listing its URL in a configuration file. The framework also manages identity, user context with consent flags, task states and traces. Its A2A server passed 97 tracked requirements in the official A2A Technology Compatibility Kit, with no failures.

Mon 26 OctMultiagent Systems
The gist
Conversational assistants like chatbots often use multiple AI agents that either rely on fixed rules or language models, but combining these effectively has been a challenge. The authors introduce EREBOTS 4.0, a new open-source software framework that helps different types of AI agents communicate and work together smoothly. It uses protocols to let language-model agents plan tasks and call specialized tools that provide exact answers. This setup makes it easier to add agents and track conversations while ensuring user privacy and task history.
Open → 2610.36221v1

Text to sql works without database documentation using query logs

Schema-Free Text-to-SQL: Learning Enterprise Database Structure from Query Logs

Abstract: Text-to-SQL systems achieve remarkable accuracy on academic benchmarks, yet performance drops dramatically in enterprise deployments. This gap stems from a fundamental assumption: existing approaches require complete schema documentation, but enterprise databases typically lack comprehensive documentation, featuring cryptic naming and implicit relationships. We present the first text-to-SQL framework that operates without schema documentation, instead learning database structure from historical query logs. Query logs encode implicit structural knowledge: which tables are queried together, how they join, and what columns map to business concepts. We construct a knowledge graph from parsed query patterns and introduce entity-driven GraphRAG retrieval that grounds user questions in domain terminology rather than relying solely on embedding similarity. Validated on both an industrial deployment with expert evaluation and the Beaver benchmark, our approach substantially outperforms similarity-based retrieval methods, the dominant industry approach, in both executability and answer quality. On Beaver, we achieve 95.7% execution validity compared to 60.8% for embedding-based retrieval, with expert data engineers preferring our system 70% to 10% on internal deployment. Our work demonstrates that text-to-SQL can operate effectively in schema-ambiguous enterprise environments, enabling natural language database interfaces "in the wild".

Sat 24 OctComputation and Language
The gist
Making computers understand questions about databases usually needs detailed info about the database’s structure. This is often missing or unclear in real business settings. The authors created a way for computers to learn how databases are organized simply by looking at past questions people asked the database. Their method builds a network of how tables and columns connect, using this to better answer new questions. This approach works much better than older methods when tested on real business databases and expert feedback.
Open → 2610.33946v1

Pairing coding agents and tools greatly affects their success and efficiency

Pairing Matters: Performance, Failures, and Efficiency in Lightweight Coding Agents

Abstract: Self-hosting coding agents is often necessary for software-engineering teams that must keep proprietary code and development traces within controlled infrastructure. Lightweight, open-weight models make such deployment more feasible by reducing hardware requirements, while strong results on repository-level benchmarks demonstrate their potential for demanding coding tasks. Deploying these models as coding agents requires pairing them with an agent harness, making their joint performance a key deployment consideration. Yet existing leaderboards primarily report fixed harness-model configurations rather than controlled comparisons across alternative pairings. To address this gap, we investigate harness-model interactions through a controlled full-factorial evaluation of six open-source harnesses and three lightweight coding models across 100 SWE-bench Verified tasks, producing 1,800 graded runs under common serving, metering, and grading conditions. For the same model, resolution rates differ by up to 44 percentage points across harnesses, while harness rankings change across models. We apply an evidence-based failure taxonomy to 1,100 unsuccessful runs and find substantial differences in failure patterns across harness-model pairings. A model's dominant failure modes under one harness need not dominate under another. Efficiency is similarly dependent on the pairing: even among model-directed loop harnesses, charged tokens per resolved task vary by more than 20-fold. These findings make harness-model selection a central deployment decision for lightweight coding agents. Strong performance with one harness or model does not guarantee similar results with another. We translate these findings into practitioner guidance for pairing selection, token-efficiency assessment, and trajectory-informed harness engineering, and release the complete experimental records and analysis artifacts.

Fri 23 OctSoftware Engineering
The gist
It matters a lot how lightweight coding AI models are paired with the software tools (called harnesses) that run them. The authors show that one model can perform very differently depending on which harness it uses. They tested many combinations and found that failure reasons and efficiency vary widely. This means picking the right harness and model pair is very important to get the best results when deploying coding AI agents.
Open → 2610.32131v1

Enterprise group chat memory structure improves information retrieval accuracy

EGCForest: Structured Agent Memory Organization for Enterprise Group Chats

Abstract: Enterprise group chats record project progress, decisions, task ownership, and other organizational information valuable to enterprise agents. Reliable retrieval is challenging because evidence spans interleaved threads, channels, and time, with meaning and authority conditioned on the speaker. Neither RAG's independent chunk retrieval nor memory systems' summary-based consolidation can reliably recover such distributed evidence. We present EGCForest, a novel multi-view hierarchical memory framework for enterprise group chats. EGCForest organizes an immutable message log into three complementary forests: a Channel forest for temporal workflows, an Actor forest for speaker-conditioned context, and an Artifact forest for deliverable lifecycles. Cross-view connections are enabled by a Placement Map and sparse structural bridges. Built on this memory backbone, EGCForest retrieves and assembles evidence by jointly leveraging message-level relevance, hierarchical context from forest summaries, and cross-view links, recovering distributed evidence. Experiments on three enterprise-chat benchmarks show that EGCForest consistently outperforms RAG and memory-system baselines, improving answer accuracy by up to 20.85 points over MemOS while supporting efficient online retrieval.

Wed 14 OctComputation and Language
The gist
Enterprise chats have lots of important information but it's hard to find because messages are spread out over many channels and come from different people. The authors created EGCForest, which organizes chat messages into three connected trees based on channel, speaker, and project deliverables. This helps find facts by looking at how messages relate in time, who said them, and how they connect across the chat history. Their tests show this method is more accurate and efficient than previous ways to search these chats.
Open → 2610.19836v1

Enterprise AI agent workflows risk crossing organizational limits

EAIR: Interaction Risks in Enterprise LLM Multi-Agent Systems

Abstract: LLM agents increasingly divide enterprise work across roles with different goals, authority, access, and information. Because each agent often sees only a local snapshot of the enterprise workflow, locally reasonable actions can still violate organization-wide constraints (e.g., several service agents can each issue credit that is individually permitted while collectively exceeding a shared compensation cap). We introduce EAIR, the first framework for analyzing enterprise multi-agent interaction risks. We make four contributions. (1) We formalize enterprise interaction risk in terms of the organizational properties that workflow operations must preserve, and operationalize this formulation as a taxonomy of testable risks with explicit failure criteria and evidence requirements. (2) We build EAIR-Worlds, a suite of executable micro-worlds that instantiates selected risks as controlled, observable workflows with explicit roles, policies, permissions, source facts, and execution traces. (3) We develop a novel diagnosis-and-repair pipeline that uses the resulting execution traces to locate contributing interaction boundaries, guide targeted workflow repairs, and retest the repaired system. (4) Large-scale experiments show recurring interaction failures across the organizational properties studied. Together, EAIR is the first operational framework for diagnosing and mitigating enterprise multi-agent interaction failures.

Sat 10 OctMultiagent Systems
The gist
Large language model agents working together in a company often have different roles and limited views of the whole process. Even if each agent acts correctly by itself, their combined actions can break important company rules, like overspending a budget. The authors created EAIR, a way to identify and fix these teamwork problems by testing and analyzing interactions in simulated work settings. Their experiments show these problems happen frequently and EAIR helps find and repair them.
Open → 2610.14800v1

Automated prefetching improves database traversal speed up to three times

Automated Prefetching for Object Spatial Programming Using Temporal Trace Graphs

Abstract: Dependent database accesses can serialize application--database round trips on a request's critical path. Planning across traversal steps requires knowing both which relationships a computation may follow and how discovered objects become subsequent execution contexts. We identify a programming-model contract that exposes this information through inspectable access paths and explicit traversal continuation. We demonstrate this contract in Object-Spatial Programming (OSP), where walkers traverse a typed object graph and execute node-type-specific code. We introduce the Temporal Trace Graph (TTG), a bounded, request-specific graph of candidate objects and traversal-derived transitions. At walker spawn, the TTG Builder composes statically extracted access and continuation rules over the live graph from the request's starting node. An asynchronous prefetcher loads planned objects while the walker executes. We implement TTG in Jac/PostgreSQL and evaluate four applications covering linear, multi-hop, recursive, and value-dependent traversals. TTG improves end-to-end latency in three applications, achieving up to 2.99x speedup over the stock runtime. Comparisons with manually staged prefetching characterize the benefits and costs of automatic cross-step planning. The evaluation also shows that planning overhead can exceed avoided demand latency and that value-dependent control can introduce bounded overfetch.

Tue 29 SeptDatabasesProgramming Languages
The gist
Many programs need to fetch related pieces of data one after another, which can slow things down. The authors propose a way to plan these fetches ahead of time by understanding how a program explores data objects and where it might go next. They create a special graph that helps predict which data to load early, speeding up the process. Testing this idea on four programs showed it can make some tasks almost three times faster, though sometimes the planning itself costs extra time.
Open → 2609.38439v1

Memory authorization protects private facts across conversations

Audience-Bound Persistent Memory: Authorization Across the Memory Lifecycle

Abstract: A personal language agent that acts for its owner across private and shared conversations can learn a fact from one audience and later place it in the context it assembles for another. We study authorization before context across the whole memory lifecycle. Each memory item carries the audience present when it was recorded; derived items are partitioned by audience, receive the intersection of their sources' audiences, or are suppressed; an audience widens only by an explicit, object-specific grant; and an item enters a model attempt only when every current viewer belongs to one of its authorized audiences, with unresolved viewers failing closed to public-only. Under explicit identity, provenance and complete-mediation assumptions, this admission is sound and policy-complete on the exact assembled context, enforced by exclusion rather than by model behavior. We realize it in two independently persisted reference architectures, a flat store and a relationship graph, and, descriptively, in a native agent-memory runtime. In a prospectively frozen confirmation over 10,000 multi-party histories, no forbidden item entered any architecture's context, whereas unscoped retrieval exposed forbidden items in 82% of its contexts. Entitled recall matched policy-equivalent baselines exactly and exceeded unscoped retrieval by 0.30 Recall@5, with a Holm-confirmed advantage that grows with distractors. No architecture produced a wrong-principal substitution, but unscoped substitutions were too rare to establish the prespecified joint decision.

Mon 28 SeptCryptography and SecurityArtificial Intelligence
The gist
When a smart assistant remembers things you say in different conversations, it needs to keep private details from being shared with the wrong people. The authors created a way to track who was listening when a memory was made and only let that memory be shared with the right groups. Their system prevents private information from leaking between different audiences, even as memories get combined or recalled later. They tested their method on many conversations and found it stopped unauthorized sharing perfectly, unlike common methods that often accidentally share private facts.
Open → 2609.36373v1

Text to SQL model accuracy improves using plans across database dialects

Closing the Cross-Dialect Gap: Query Plans as a Portable Interface in Text-to-SQL

Abstract: Text-to-SQL systems are typically trained and evaluated on a single dialect (SQLite), yet production deployments span PostgreSQL, MySQL, ClickHouse, and beyond. We show that this single-dialect assumption leads to a substantial drop in cross-dialect accuracy for every model we tested. The drop persists across scale, architecture, and even purpose-built text-to-SQL systems. We argue that the fix is to change the generation target: instead of asking an LLM to emit dialect-specific SQL, we have it emit a dialect-agnostic relational algebra query plan, which a deterministic compiler then renders into SQL for any supported backend. Across thirteen models from 3B to frontier scale, this restores cross-dialect portability nearly uniformly, at a small cost in peak accuracy on the model's home dialect for capable prompted models and none once fine-tuned on plans; under matched fine-tuning, plan supervision yields a stronger model than SQL supervision. We also introduce MetricName, a question-aware result-set comparator needed to evaluate fairly across dialects, where existing metrics confound semantic errors with benign cross-dialect variation. More broadly, the result is a reminder that a generation target chosen for execution is not necessarily the one that maximizes generation quality.

Sun 27 SeptComputation and Language
The gist
Text-to-SQL models usually learn one type of database language, which causes errors when used with others. The authors show this is a big problem for many models. They suggest having the model produce a general query plan, which can be turned into any specific database language afterwards. This method improves accuracy across many SQL languages without hurting performance on the original language, and sometimes even improves it. They also created a new way to fairly measure correctness across different database languages.
Open → 2609.33670v1

Page images improve document QA accuracy but increase latency and cost

Text, Pixels, or Both? Evaluating Input Representations for Multimodal Document QA

Abstract: Every document QA system begins with a choice that is rarely studied on its own: whether to feed the model page images, extracted text, or both. We isolate this choice, holding the prompt, judge, and scoring pipeline fixed, across four commercial model endpoints, two corpora, and two context regimes (gold evidence pages and the full document). On documents that fit the image budget, page images lead on accuracy at every document length on both corpora, but this advantage carries a growing latency and cost premium: text latency stays roughly flat as documents lengthen while image latency rises steadily. Text and images also fail on different questions, with exactly one representation correct on 19--25% of items across the reported cells, so neither subsumes the other. Exploiting this complementarity, a lightweight TF-IDF router that reads only the question text gains 2.6 points over always-text while cutting median latency 30% relative to always-vision, on a document-disjoint held-out split.

Fri 18 SeptArtificial Intelligence
The gist
When computers answer questions about documents, they can use either the words extracted from the pages, images of the pages themselves, or both. This paper shows that using page images generally helps computers answer more accurately but takes more time and computing power as documents get longer. Interestingly, some questions are answered correctly only by looking at images or only by looking at text, so using both can be better. The authors also built a simple system that chooses between text or image input based on the question, improving speed and accuracy.
Open → 2609.22628v1

Small models coordinate to solve complex tasks without cloud reliance

OrchSLM: Probing the Dynamics of Small Language Model Orchestration

Abstract: Although large language models (LLMs) have demonstrated remarkable capabilities, their reliance on cloud-scale infrastructure poses fundamental challenges for deployment in agentic pipelines, including latency, privacy, connectivity, and substantial computational cost. Small language models (SLMs) offer a compelling alternative: recent studies suggest that many repetitive and narrowly scoped subtasks in agentic workloads may be better served by specialized SLMs than by monolithic LLMs. However, the limited capacity and context windows of SLMs can constrain long-horizon reasoning and interaction-heavy orchestration strategies such as iterative verification and debate. This motivates a complementary, non-interactive paradigm in which heterogeneous SLMs independently generate candidate solutions and a router orchestrates their cached samples without further model interaction. To further understand the mechanisms of such orchestration, we introduce OrchSLM, a routing framework that unifies existing non-interactive orchestration methods and exposes their underlying design choices as controllable parameters. Using OrchSLM as a systematic probe, we reveal how orchestration behavior emerges from diverse knobs, including the task structure, model-pool composition, and multi-agent consensus.

Fri 11 SeptArtificial Intelligence
The gist
Using big language models can be slow, expensive, and require constant internet. The authors explore how smaller language models can each work on parts of a problem independently and then get combined by a system that picks the best answers without the models talking to each other. They introduce OrchSLM, a way to study how different settings affect this coordinating system. This helps us understand how smaller models can team up effectively without needing lots of computing power or online connection.
Open → 2609.13470v1

Graph rAG improves code migration by preserving structure and dependencies

Beyond Vector Similarity: Hierarchical Context-Aware Graph RAG vs Standard RAG in Enterprise Code Migration

Abstract: As enterprises modernize legacy monolithic systems to microservices, Large Language Models (LLMs) are heavily utilized for automated code translation. However, traditional vector-based Retrieval-Augmented Generation (Standard RAG) struggles to capture topological relationships. It fetches isolated chunks that sever inheritance chains, leading to high compilation failure rates. This paper introduces a Hierarchical Context-Resident Graph (HCRG) methodology to resolve these limitations. Our pipeline uses tree-sitter for Abstract Syntax Tree (AST) extraction, maps architectural edges into a Google Cloud Spanner Property Graph, and serializes this structure into a Gemini Context Cache for topological, parent-first code translation. We shift evaluation from naive text-overlap to a custom 7-metric Software Engineering framework. Traditional metrics like CodeBLEU (which scored 91% for both methods) effectively masked Standard RAG's structural failures behind syntactically plausible but broken code. Empirically, Graph RAG decisively mitigates dependency loss: API hallucination rates dropped from 56.4% to 16.2%, Dependency Resolution Quality improved from 34.8% to 65.9%, and Parent-Child Consistency rose from 26.7% to 45.5%. However, Graph RAG introduces specific trade-offs. The dense global context causes defensive over-engineering by the LLM, reducing Cyclomatic Complexity Consistency from 71.6% to 46.7%, and slightly degrades Docstring Preservation (67.0% to 61.0%). Ultimately, while trading code complexity for reduced hallucinations, Graph RAG provides a substantially more viable, architecturally sound path for automated enterprise codebase modernization.

Fri 11 SeptArtificial Intelligence
The gist
Modernizing old software into smaller, manageable parts is hard, especially when automatically translating code with AI. The authors show that the usual method which treats code pieces separately misses important connections, causing many errors. They introduce a new approach that understands the code's structure better by using graphs to keep track of these connections. This new method makes the translated code more reliable, although sometimes it creates slightly more complex code than before.
Open → 2609.12464v1

Retrieval-confidence layer detects missing context in enterprise code generation

RCL: A Retrieval-Confidence Layer for Detecting Insufficient Context in Enterprise Retrieval-Augmented Code Generation

Abstract: Retrieval-Augmented Generation (RAG) for code generation has been studied extensively on public repositories, where a model's parametric knowledge often compensates for imperfect retrieval. This breaks down in enterprise codebases, where private APIs, internal frameworks, and undocumented team conventions fall entirely outside any model's pretraining distribution. Recent work on private-library code generation shows that even oracle (perfect) retrieval does not eliminate errors, but locates failures downstream in API usage; separately, confidence-gated retrieval has been studied for open-domain question answering using model-internal confidence. Neither addresses whether retrieval itself was structurally sufficient for a private-code query before generation begins. We introduce RCL (Retrieval-Confidence Layer), a lightweight module inserted between retrieval and generation that combines a call-graph-derived structural coverage score with a novelty score estimating a query's dependence on knowledge outside the model's prior, to detect insufficient retrieval before generation occurs. When confidence falls below a calibrated threshold, RCL triggers a targeted follow-up retrieval or labels the output for human review, rather than generating silently against incomplete context. We describe RCL's architecture, formalize its scoring functions, and propose an evaluation methodology using a private-code benchmark built by injecting synthetic internal APIs into open-source Java repositories, simulating the enterprise condition without proprietary code. We report results (Section 7) comparing RCL against similarity-only retrieval on generation correctness. Our position is that retrieval sufficiency, assessed structurally rather than from model-internal confidence, is a distinct and currently underaddressed signal for building safer code-generation systems in private, enterprise settings.

Thu 10 SeptSoftware Engineering
The gist
Generating code with AI often relies on retrieving related code snippets, but in private company codebases, this retrieval misses important internal or undocumented parts. The authors propose a new method called RCL that checks whether the retrieved code covers enough relevant parts before the AI tries to write new code. If it detects missing pieces, it can call for more searching or ask for human help instead of risking wrong code. They tested RCL using a simulation with injected internal APIs to mimic private code environments.
Open → 2609.11023v1