A Phased Workflow for Operating LLM-Based Coding Agents

A Phased Workflow for Operating LLM-Based Coding Agents Ante Kapetanovic

ankapetanovic@infobip.com Infobip Split, Croatia

Tomislav Duricic

tduricic@infobip.com Infobip Zagreb, Croatia

arXiv:2608.30701v1 [cs.SE] 31 Aug 2026

Abstract LLM-based coding agents combine a foundation model with a harness that shapes agent behavior. For non-trivial tasks, how practitioners structure their work with the coding agents determines whether reliable results follow. We report on a phased workflow for operating coding agents developed by the AI research team at Infobip. The workflow structures agent-assisted development into four phases where human effort is front-loaded and delegation increases as artifacts mature. Context management is the central concern, addressed through four strategies applied at each phase to counter known failure modes. From practitioner experience, we observe that upstream errors in research and planning can compound across later phases, while correcting generated code can introduce bloat and fragility. This motivates front-loading human review. We identify two open problems: the absence of metrics for workflow effectiveness and the gap between formalized context management components and the workflow-level patterns that practitioners need.

CCS Concepts • Software and its engineering → Software development process management.

Keywords harness engineering, context management, phased workflow ACM Reference Format: Ante Kapetanovic, Tomislav Duricic, Andro Mercep, and Emanuel Lacic. 2026. A Phased Workflow for Operating LLM-Based Coding Agents. In Proceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM ’26), November 07–11, 2026, Rome, Italy. ACM, New York, NY, USA, 2 pages. https://doi.org/10.1145/3799682.3839253

1

Introduction

LLM-based agents have been broadly applied across software engineering tasks [10], but their effectiveness on non-trivial tasks depends less on the choice of foundation model than on how practitioners configure the agent’s harness. Böckeler [2] distinguishes the provider harness, built into the agent by its vendor, from the user harness, which practitioners configure through project-level instructions [4], tool selection, session structure, and context management. Performance degrades consistently with input length even on trivial tasks [5], multi-turn settings show an average 39% performance drop [9], and irrelevant context reduces accuracy even This work is licensed under a Creative Commons Attribution 4.0 International License. CIKM ’26, Rome, Italy © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2539-5/2026/11 https://doi.org/10.1145/3799682.3839253

Andro Mercep

amercep@infobip.com Infobip Zagreb, Croatia

Emanuel Lacic

emlacic@infobip.com Infobip Zagreb, Croatia

when the correct answer is present [5]. Overall, unstructured use of AI coding tools can reduce developer productivity [1]. These findings motivate structured approaches to agentic development. We report on a phased workflow for operating coding agents at Infobip,1 a cloud communications platform that is supported by around 900 engineers and processes over 42 billion messages monthly across more than 190 countries. Extending the researchplan-implement paradigm [6], the workflow structures agentassisted development into four phases where human effort decreases as artifacts mature. In our experience, flawed research can propagate into flawed plans and code, while correcting generated code can introduce bloat and fragility. This motivates front-loading human review. Our contributions are thus: (1) a phased workflow for operating coding agents, (2) concrete practices for configuring the user harness at each phase, and (3) introduction of two open problems for the research community.

2

Phased Workflow

Our proposed workflow consists of four phases: research, planning, task definition, and implementation. Research and planning are performed once per project; task definition and implementation repeat as tasks are executed and refined. Human involvement is highest in the upstream phases, where errors carry the greatest cost, and decreases as artifacts mature. When implementation reveals poorly defined tasks, the practitioner returns to task definition instead of patching the implementation. At each phase, the practitioner manages context through four strategies described by Martin [11]: write (persist information outside the context window), select (retrieve relevant information into the window), compress (retain only required tokens), and isolate (split context across sessions or agents). These strategies counter failure modes identified by Breunig [3]: distraction (over-reliance on accumulated patterns), confusion (irrelevant content competing for attention), poisoning (hallucinations persisting across turns), and clash (new information conflicting with existing context). The relationship is not one-to-one: isolating context in fresh sessions prevents both poisoning and distraction, while compressing findings into a summary reduces both confusion and distraction. Each phase applies strategies matched to its specific risks. Research. The practitioner and agent explore the problem space together. The agent operates with access limited to read operations, codebase search, and domain-specific tools such as literature search. The practitioner guides research direction but withholds opinions to avoid anchoring the agent’s exploration. All findings are validated before proceeding. This phase selects context by loading only research-relevant tools and isolates the session to a focused scope, thus reducing the risk of confusion from irrelevant tool definitions 1Workflow materials: https://github.com/infobip/agentic-development-workflow

CIKM ’26, November 07–11, 2026, Rome, Italy

and distraction from unrelated context. The output is a curated research document that captures validated findings. Planning. Using the research document as input, the practitioner and agent develop an implementation approach through iterative discussion. The practitioner works in the agent’s default operating mode rather than a dedicated planning mode. We found that dedicated planning modes push the agent to finalize prematurely, producing plan artifacts before the problem is sufficiently understood. When the approach is settled, the practitioner reduces the discussion to validated decisions and writes them to a persistent artifact that replaces the full conversation in subsequent phases. The act of manual curation is the primary application of the compress strategy in the workflow: it discards abandoned lines of reasoning and retains only what subsequent phases need, preventing poisoning from earlier missteps. Task definition. Each machine-readable task records a stable identifier, goal, dependencies, relevant code paths, acceptance criteria, and validation method. Tasks are sized to complete in a fresh session and split when the required context would exceed the agent’s effective operating range, which can be substantially below nominal capacity [5, 8]. Implementation. Each task runs in a fresh session loaded with project-level instructions and the task definition. The task registry stores status, dependencies, acceptance criteria, and the latest outcome; an append-only activity log records actions, validation results, changed files or commits, failures, and the next action. Git stores code state, while the registry and log store workflow state, making conversation state disposable. After an interruption, a fresh session reads these artifacts, inspects the working tree and latest commit, and resumes or reverts incomplete work. The agent then implements, validates, logs, updates task status, commits, and terminates under manual supervision or in an autonomous loop. Project-level instructions are hand-crafted and evolve over time. When the practitioner observes the agent repeating a mistake across sessions, a targeted correction is added. Since instruction-following accuracy degrades with instruction count [7], corrections are kept to concise single-line entries. The practitioner reviews output rather than writing it, but retains ownership of the overall process.

3

Open Problems

Two problems remain unresolved. First, there are no established metrics for workflow effectiveness. Practitioners cannot measure whether their phased workflow improves outcomes compared to unstructured delegation, whether task granularity is appropriate, or whether instructions are well-calibrated. Existing coding agent benchmarks have known limitations that make them unreliable proxies for workflow effectiveness. Candidate metrics might include task success rate per session, instruction correction rate, and context utilization at task completion, but these remain unexplored. Second, research formalizes individual components of context management, such as pruning, compression, and tool selection, but not the workflow-level patterns that compose them. Zhang et al. [12] demonstrate that structured context management yields measurable gains on agent benchmarks, but these gains are measured at the component level, not across practitioner workflows.

Ante Kapetanovic, Tomislav Duricic, Andro Mercep, and Emanuel Lacic

The absence of shared terminology makes it difficult to compare or transfer approaches across teams and domains.

Acknowledgments This work was supported in part by the Infobip Global Communication Platform project (PK.1.1.07.0001), conducted within the Important Project of Common European Interest on Next Generation Cloud Infrastructure and Services (IPCEI-CIS).

Speaker Bio Ante Kapetanovic is a Senior Researcher at Infobip, where he works on human-AI interaction, conversational AI and information retrieval, and trustworthiness.

Relevance This proposal addresses three CIKM Industry Day topics: system design from industry practitioners (a phased workflow for operating coding agents), domain-specific challenges (context management in agent-assisted development), and collaborative investigation between industry and academia (open problems on workflow metrics and practitioner patterns).

GenAI Usage Disclosure Generative AI tools were used to support the conceptualization of this article and to assist in drafting the accompanying repository. Google Scholar Labs was used to discover relevant references.

References [1] Joel Becker, Nate Rush, Elizabeth Barnes, and David Rein. 2025. Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity. doi:10.48550/arXiv.2507.09089 [2] Birgitta Böckeler. 2026. Harness Engineering for Coding Agent Users. https: //martinfowler.com/articles/harness-engineering.html Blog post. [3] Drew Breunig. 2025. How Long Contexts Fail. https://www.dbreunig.com/2025/ 06/22/how-contexts-fail-and-how-to-fix-them.html Blog post. [4] Thibaud Gloaguen, Niels Mündler, Mark Niklas Mueller, Veselin Raychev, and Martin Vechev. 2026. Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents? doi:10.48550/arXiv.2602.11988 [5] Kelly Hong, Anton Troynikov, and Jeff Huber. 2025. Context Rot: How Increasing Input Tokens Impacts LLM Performance. Technical Report. Chroma. https: //research.trychroma.com/context-rot [6] Dexter Horthy. 2025. Advanced Context Engineering for Coding Agents. Technical Report. HumanLayer. https://github.com/humanlayer/advanced-contextengineering-for-coding-agents [7] Daniel Jaroslawicz, Brendan Whiting, Parth Shah, and Karime Maamari. 2025. How Many Instructions Can LLMs Follow at Once? doi:10.48550/arXiv.2507.11538 [8] Yuri Kuratov, Aydar Bulatov, Petr Anokhin, Ivan Rodkin, Dmitry Sorokin, Artyom Sorokin, and Mikhail Burtsev. 2024. BABILong: Testing the Limits of LLMs with Long Context Reasoning-in-a-Haystack. In Advances in Neural Information Processing Systems, Vol. 37. Curran Associates, Inc., Red Hook, NY, USA, 106519– 106554. doi:10.52202/079017-3381 [9] Philippe Laban, Hiroaki Hayashi, Yingbo Zhou, and Jennifer Neville. 2026. LLMs Get Lost In Multi-Turn Conversation. doi:10.48550/arXiv.2505.06120 published at International Conference on Learning Representations 14. [10] Junwei Liu, Kaixin Wang, Yixuan Chen, Xin Peng, Zhenpeng Chen, Lingming Zhang, and Yiling Lou. 2026. Large Language Model-Based Agents for Software Engineering: A Survey. ACM Transactions on Software Engineering and Methodology Just accepted (2026), 87 pages. doi:10.1145/3796507 [11] Lance Martin. 2025. Context Engineering for Agents. https://rlancemartin.github. io/2025/06/23/context_engineering/ Blog post. [12] Qizheng Zhang, Changran Hu, Shubhangi Upasani, Boyuan Ma, Fenglu Hong, Vamsidhar Kamanuru, Jay Rainton, Chen Wu, Mengmeng Ji, Hanchen Li, Urmish Thakker, James Zou, and Kunle Olukotun. 2026. Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models. doi:10.48550/arXiv.2510. 04618

Related documents

• A Phased Workflow for Operating LLM-Based Coding Agents#818756
• A Phased Workflow for Operating LLM-Based Coding Agents#808764
• Execution-First Synthetic Tool-Use Trace Generation for LLM Agents#997524
• Towards the Readability of LLM-Generated Codes through Multitask Representation Engineering#259536
• Case Studies and Reflections on Agentic Software Engineering for Rapid Development of Digital Music Instruments#217809