Paper deep dive

Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents

Chanjin Park

Year: 2026Venue: arXiv preprintArea: cs.AIType: PreprintEmbeddings: 78

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%

Last extracted: 7/20/2026, 8:44:25 PM

Summary

The paper proposes Agentic Problem Frames (APF), a systematic engineering framework for developing reliable domain agents. It addresses the risks of 'frameless' LLM development (scope creep, hallucination, open-loop failures) by introducing the Agentic Job Description (AJD) to define jurisdictional boundaries and the Act-Verify-Refine (AVR) loop for closed-loop control. Grounded in Michael Jackson's Problem Frames theory, APF shifts focus from internal model tuning to structured interaction between the agent and its environment, ensuring requirements are satisfied through dynamic specification and verified knowledge assets.

Entities (8)

Agentic Problem Frames · framework · 98%Agentic Job Description · specification-tool · 97%Act-Verify-Refine Loop · process · 96%Large Language Models · technology · 95%Problem Frames Theory · theoretical-foundation · 94%Michael Jackson · person · 92%Business Travel Proxy · case-study · 90%Industrial Equipment Management · case-study · 90%

Relation Signals (7)

Agentic Problem Frames → implements → Act-Verify-Refine Loop

confidence 95% · At its core, the Act-Verify-Refine (AVR) loop functions as a closed-loop control system... To operationalize this, this study introduces the Agentic Job Description

Agentic Problem Frames → uses → Agentic Job Description

confidence 95% · To operationalize this, this study introduces the Agentic Job Description (AJD)... By applying AJD-based specification and APF modeling to these scenarios

Agentic Problem Frames → basedon → Problem Frames Theory

confidence 93% · this study adopts Michael Jackson’s Problem Frames (PF) theory as its theoretical foundation.

Agentic Job Description → defines → jurisdictional boundaries

confidence 92% · AJD, a formal specification tool that defines jurisdictional boundaries, operational contexts, and epistemic evaluation criteria.

Act-Verify-Refine Loop → transforms → execution results

confidence 90% · transforms execution results into verified knowledge assets

Agentic Problem Frames → validateswith → Business Travel Proxy

confidence 88% · The efficacy of this framework is validated through two contrasting case studies: a delegated proxy model for business travel

Agentic Problem Frames → validateswith → Industrial Equipment Management

confidence 88% · and an autonomous supervisor model for industrial equipment management.

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Large Language Models (LLMs) are evolving into autonomous agents, yet current "frameless" development--relying on ambiguous natural language without engineering blueprints--leads to critical risks such as scope creep and open-loop failures. To ensure industrial-grade reliability, this study proposes Agentic Problem Frames (APF), a systematic engineering framework that shifts focus from internal model intelligence to the structured interaction between the agent and its environment. The APF establishes a dynamic specification paradigm where intent is concretized at runtime through domain knowledge injection. At its core, the Act-Verify-Refine (AVR) loop functions as a closed-loop control system that transforms execution results into verified knowledge assets, driving system behavior toward asymptotic convergence to mission requirements (R). To operationalize this, this study introduces the Agentic Job Description (AJD), a formal specification tool that defines jurisdictional boundaries, operational contexts, and epistemic evaluation criteria. The efficacy of this framework is validated through two contrasting case studies: a delegated proxy model for business travel and an autonomous supervisor model for industrial equipment management. By applying AJD-based specification and APF modeling to these scenarios, the analysis demonstrates how operational scenarios are systematically controlled within defined boundaries. These cases provide a conceptual proof that agent reliability stems not from a model's internal reasoning alone, but from the rigorous engineering structures that anchor stochastic AI within deterministic business processes, thereby enabling the development of verifiable and dependable domain agents.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

76,738 characters extracted from source content.

Expand or collapse full text

AGENTIC PROBLEM FRAMES: A SYSTEMATIC APPROACH TO ENGINEERING RELIABLE DOMAIN AGENTS A PREPRINT Chanjin Park Institute of Engineering Research Seoul National University Seoul, Korea calling6@snu.ac.kr February 24, 2026 ABSTRACT Large Language Models (LLMs) are evolving into autonomous agents, yet current “frameless” development—relying on ambiguous natural language without engineering blueprints—leads to critical risks such as scope creep and open-loop failures. To ensure industrial-grade reliability, this study proposes Agentic Problem Frames (APF), a systematic engineering framework that shifts focus from internal model intelligence to the structured interaction between the agent and its environment. The APF establishes a dynamic specification paradigm where intent is concretized at runtime through domain knowledge injection. At its core, the Act-Verify-Refine (AVR) loop functions as a closed-loop control system that transforms execution results into verified knowledge assets, driving system behavior toward asymptotic convergence to mission requirements (R). To operationalize this, this study introduces the Agentic Job Description (AJD), a formal specification tool that defines jurisdictional boundaries, operational contexts, and epistemic evaluation criteria. The efficacy of this framework is validated through two contrasting case studies: a delegated proxy model for business travel and an autonomous supervisor model for industrial equipment management. By applying AJD-based specification and APF modeling to these scenarios, the analysis demonstrates how operational scenarios are systematically controlled within defined boundaries. These cases provide a conceptual proof that agent reliability stems not from a model’s internal reasoning alone, but from the rigorous engineering structures that anchor stochastic AI within deterministic business processes, thereby enabling the development of verifiable and dependable domain agents. Keywords Agentic AI· Software Engineering for AI· Problem Frames· Requirements Engineering 1 Introduction 1.1 Background: The Risks of Frameless Development and the Necessity of Engineering Artificial Intelligence has evolved beyond simple chat interfaces into the era of Agentic AI, where models are integrated with legacy systems and physical equipment to perform practical tasks. This shift implies that AI has emerged as a specialized workforce within industrial sectors. However, while the pace of technological advancement has been rapid, engineering methodologies have lagged behind. Consequently, current development remains in a frameless state—lacking the structural discipline required to ensure the quality of individual components within a complex system. From a software engineering perspective, for an agent to function as a reliable engineering component, its boundaries and input/output must be strictly defined, even if its internal logic remains a black box. In this study, such structuring begins with the establishment of a Job Description (JD). Developing without a JD is akin to deploying a highly educated but inexperienced new employee to a field without any guidance. An agent, like a new recruit with strong academic arXiv:2602.19065v1 [cs.AI] 22 Feb 2026 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT background (general intelligence) but no domain-specific experience, requires a clear definition of its mission, authority, and work environment. Furthermore, the JD must specify the reference materials for the task and the criteria by which the performance will be evaluated. When combined with the inherent stochasticity of agents, the absence of this foundational structure leads to the following critical risks: •Absence of Boundaries (Scope Creep): This is akin to a “recruit who does not know the line”. LLMs possess vast general knowledge. Without clearly defined jurisdictional boundaries, an agent may rely on general common sense to access systems beyond its authority or interfere with unnecessary domains. When accidents occur, a responsibility gap arises; it becomes unclear whether the failure was the model’s reasoning error or the manager’s failure to provide explicit regulations and work permissions. •Absence of Grounding (Knowledge & Reality Gap): This resembles a “recruit who works by guesswork”. Agents often fill in incomplete or ambiguous inputs with probabilistic guesses. Without domain knowledge (K) provided as a baseline to anchor the user’s intent, the agent will formulate erroneous plans based on hallucinated assumptions. This lack of initial grounding creates a disconnect between the user’s actual requirement and the agent’s internal reasoning, rendering the starting point of the mission unreliable. •Absence of Feedback (Open-Loop): This is the case of a “recruit who skips the engineering report”. Without a systematic callback mechanism or human confirmation, the agent falls into an open-loop state, relying on the flawed assumption that “execution equals success.” This leads to a severe state mismatch between the actual world and the agent’s internal assumptions, especially when an agent concludes task completion based solely on a successful API call without confirming the actual state change. Furthermore, the lack of feedback prevents the system from assetizing execution results into verified knowledge, thereby hindering the agent’s ability to refine its subsequent actions through asymptotic convergence. Recent research by Huang et al. [2025] underscores the necessity of addressing this engineering crisis. Their study indicates that experienced developers tend to reject "vibe coding"—which delegates full authority to AI—and instead prefer to strictly control AI through explicit context provision (input) and rigorous result verification (output). This paper responds to these industrial requirements and aims to transform frameless development into a controllable engineering process by defining structured boundaries for both input and output 1.2 Proposed Approach: Structuring via Agentic Problem Frames Modern Software Engineering (SE) and Requirements Engineering (RE) have primarily focused on deriving the specification (S) for the Machine (M) to satisfy requirements (R), while ensuring that the implementation aligns with the domain knowledge (K) concerning the World (W). In this paradigm, the central concerns are: “Has the user’s need been accurately translated into a spec?” and “Is the software implemented without errors according to that spec?”. However, this implementation-centric approach is no longer valid in an agentic environment because the internal logic of the machine (M) is a black box that operates probabilistically. Unlike traditional software, specifications for agents cannot be fixed at design time. This is because trigger events, such as a user’s vague request to "prepare for a business trip" or an ambiguous anomaly signal from a motor, are inherently incomplete. To bridge this gap, the specification must manifest as a Dynamic Specification (S t ), concretized just before execution by injecting domain-specific context—such as corporate policies, technical manuals, or historical data. Consequently, rather than attempting to tune the uncontrollable internals of the agent—such as through model fine- tuning—this study focuses on strictly structuring the external world and interaction mechanisms. By bounding the agent’s reasoning within a professional jurisdictional context through an Agentic Job Description, this study transforms a general-purpose probabilistic model into a reliable engineering component capable of fulfilling specific missions. To address the inherent uncertainty of agents, this study adopts Michael Jackson’s Problem Frames (PF) theory as its theoretical foundation. PF shifts the focus from the machine’s internal code to the interaction between the machine (M) and the world (W), expressed through the requirement satisfaction argument:S, K ⊢ R. This reasoning implies that even ifMis an uncontrollable black box,the proposed methodology enables the satisfaction of requirements (R) by rigorously designing the specifications (S) through which the machine meets the world, while accurately reflecting domain knowledge (K). Building upon this, this paper proposes Agentic Problem Frames (APF) to transform probabilistic machines into controllable engineering components. The core logic of APF is to achieve requirement satisfaction not through a single static proof, but through asymptotic convergence driven by three mechanisms: • Dynamic Specification (S t ): At runtime, ambiguous user requests are complemented with jurisdictional context to bound the machine’s reasoning range. 2 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT •Knowledge Transformation (K t+1 ): Opaque state changes in the world are converted into confirmed knowledge through a rigorous verification process. •Feedback Loop: This newly acquired knowledge is fed back as context for the next cycle, allowing the system to incrementally satisfy R through iterative evolution. For the practical development of such agents, the Agentic Job Description is introduced as the foundational engineering specification. Just as a professional contract defines the mission and authority of a human recruit, the AJD functions as a blueprint that prescribes the jurisdictional boundaries, operational contexts, and epistemic evaluation criteria for the agent. By defining these discrete units through the AJD, this approach transforms a stochastic model into a mission-oriented Job Performer, ensuring that its autonomous judgment is anchored within the APF framework. This approach represents a paradigm shift from traditional internal code correctness toward fitness, demonstrating how the evolutionary interaction between the machine and the world ultimately ensures reliability in complex industrial domains. 2 Background and Related Work 2.1 Problem Frames Theory and Structuring Agentic Environments This study adopts the Problem Frames theory, pioneered by Michael Jackson and Pamela Zave Jackson [2001], as its theoretical foundation. Unlike traditional requirements engineering methods that focus on specifying the machine’s internal functions or behavioral requirements, PF emphasizes modeling the problem space itself. The essence of PF lies in shifting the focus from the machine’s internal implementation to the interaction between the machine (M) and the world (W). In an agentic environment, where the machine is an autonomous black box performing probabilistic execution, this interaction-centric view is essential. By leveraging PF, the objective is not to specify the uncontrollable internal logic of the Large Language Model (LLM); instead, this framework tames its stochastic behavior by strictly structuring the shared phenomena through which the agent meets the world. This approach enables the transformation of a general-purpose probabilistic model into a reliable engineering component by grounding its reasoning within domain-specific knowledge (K) 2.1.1 The Essence of Problem Frames: Structuring the World, Not the Machine The core of Jackson’s PF theory lies not in designing the internals of the machine (M), but in structuring the world (W) with which the machine interacts. Zave and Jackson [1997] criticized the common tendency to focus exclusively on code—neglecting the environment—as implementation bias. They defined requirements (R) not as the machine’s internal behavior, but as the "desirable state changes to be achieved in the world (W) through the machine’s actions". For instance, sending a control signal is merely a machine specification (S), while the result—"the elevator safely arriving at the desired floor"—is the actual requirement (R) fulfilled in the world. This relationship is demonstrated through the requirement satisfaction argument: S, K ⊢ R This formula implies that the specification (S) alone cannot satisfy the requirement (R); it must be combined with domain knowledge (K). While this theory remained a minority view in mainstream software engineering for the past 30 years, it was largely because traditional digital environments were assumed to be causal and deterministic. In such a world, developers could achieve system stability through internal correctness—operating under the optimistic assumption that once a command is correctly issued by the machine, the world will invariably react as designed. However, the rise of Agentic AI reverses this situation. In this new paradigm, the machine (an LLM) is a black box that perceives and communicates through ambiguous natural language, rather than deterministic logic. Unlike traditional systems, a probabilistic agent cannot internally guarantee the causal outcomes of its actions in a complex world. Without a feedback mechanism to verify if execution results align withR, an agent faces structural limitations in correcting its probabilistic judgments. Thus, controlling this uncertainty necessitates the injection of domain knowledge (K) as external context and the physical verification of state changes. These verified changes are then assetized as new context, forming a dynamic cycle that enhances the consistency of subsequent actions. Ultimately, structuring the world and implementing post-verification mechanisms are essential to preventing hallucination. 2.1.2 Dependability via Decomposition: Isolating Uncertainty To solve complex software problems, Jackson [2004] emphasized decomposing the machine into verified "known problem classes" rather than treating it as a big monolithic entity. He identified dependability exposure—a state where a machine operates based on false assumptions about the world without verification—as the fundamental cause of 3 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT system failure. This insight accurately foretells the engineering risks of modern LLM agents. A big monolithic agent, lacking structured boundaries, is likely to mobilize vast, irrelevant knowledge without context, leading to erroneous execution. If the scope of the world an agent must handle is too broad, the agent inevitably relies on numerous uncertain assumptions. The engineering essence of decomposition is to isolate the world’s uncertainty and minimize the number of assumptions, thereby ensuring a state where each action can be objectively verified. Following the principle of isolation through decomposition, this study employs the Agentic Job Description to break down ambiguous agent roles into clear job units. By defining these discrete units, the propagation of uncertain assumptions is physically blocked ensuring that each agent functions as a reliable, verifiable component. This modular approach allows for the composition of complex, stable organizations from atomic unit agents. When individual agents are reliably defined as mission-oriented components, the overall system can scale into a coordinated "workforce" or agentic organization, where the reliability of the whole is grounded in the verified performance of its constituent units. 2.1.3 Classification of the World: Domain Natures and Control Strategies Structuring the world begins with identifying the nature of the domains with which the machine interacts. Control strategies and verification methods must fundamentally differ depending on whether a target follows physical/logic laws, possesses autonomy, or consists of structured information. Jackson [2001] categorized these based on their response characteristics: •Causal Domains (Deterministic Interaction): These environments show predictable reactions according to physical laws or designed logic (e.g., hardware sensors, internal APIs). While they cannot "refuse" a command, the agent must not assume success based solely on a sent signal. For instance, after a "A public transportation booking API call, the agent must perform technical verification—such as monitoring confirmation emails or checking status callbacks—to ensure the intended state change actually occurred in the world. •Biddable Domains (Autonomous Interaction): These are non-deterministic environments with their own autonomy or business constraints, most notably human users. A biddable domain can refuse requests based on internal states or preferences. Since the machine cannot force execution, the strategy must be bid- ding—proposing an action and waiting for human confirmation. For example, the final itinerary comprising transportation and lodging should only be finalized after a human’s "value confirmation." •Lexical Domains (Static Information): These consist of static data such as manuals, jurisdictional context, or historical logs. In an agentic environment, these are not targets of control but sources of knowledge (K). The control strategy here focuses on precise retrieval; these domains must be injected as context to ground the agent’s reasoning, ensuring that the "probabilistic guess" is replaced by "domain-specific judgment." 2.2 Trends in LLM Agent Engineering Research Recent research on agents has focused on enhancing internal reasoning capabilities by reflecting the results of interactions with the world. However, engineering approaches to control these agents as reliable, predictable systems have been not enough. Agents in industrial settings must not be mere consumers of general knowledge; they must become engineering entities that reliably execute specific missions within strictly defined boundaries. Therefore, modeling and structuring the world—specifically the rules and boundaries required for an agent’s mission—must precede unstructured adaptation or trial-and-error learning. Without a predefined problem frame, an agent’s reasoning remains ungrounded, leading to unpredictability in complex workflows. This section reviews major prior works and discusses how the proposed APF complements their limitations to ensure agent reliability through structural rigor. 2.2.1 Challenges in AI Systems Engineering: Ambiguity in Specifying Desired Outcomes Attempts to handle AI from a traditional Software Engineering (SE) perspective have persisted, yet a gap between theory and practice remains. Bosch et al. [2021] identified through industrial case studies that the primary bottleneck in moving ML models to production lies in the ambiguity of “specifying desired outcomes.” The essence of this ambiguity lies in the fact that agent behavior is governed by probabilistic inference rather than deterministic logic. Unlike traditional software, where a specification (S) serves as a static blueprint for code, a specification for an agent cannot be fully fixed at design time. This limitation arises because trigger events—such as vague user requests or unpredictable environmental signals—are inherently incomplete. To bridge this gap, the specification must evolve into a dynamic specification (S t ), which is manifested at the moment of execution (t) by augmenting ambiguous inputs with the domain knowledge available at that time (K t ). 4 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT This research addresses these challenges by proposing a structure that clearly delineates an agent’s jurisdictional boundaries via Agentic Job Description. By assetizing execution results into verified domain knowledge for continuous feedback, this framework transforms initially uncertain executions into a process that incrementally satisfies requirements (R) through iteration. This approach reframes the specification challenge from a problem of "initial correctness" to one of dynamic grounding and verification. 2.2.2 Combining Reasoning and Acting: Toward Verified Grounding In the evolution of agent architectures, Chain-of-Thought (CoT) research has provided a foundational milestone by proving that LLMs can perform deep reasoning through step-by-step cognitive processes [Wei et al., 2022]. This internal reasoning capability is a crucial component of modern agents. Building upon this, the ReAct framework demonstrated a powerful paradigm of interleaving reasoning and acting, allowing agents to dynamically adjust their plans based on observations from the world [Yao et al., 2023]. While acknowledging the significant contributions of these approaches, this study identifies an engineering gap in the way observations are handled. In the ReAct paradigm, environmental feedback is primarily processed as natural language context. From a systems engineering perspective, this relies on the model’s internal consistency to interpret results correctly, which may be vulnerable to hallucinations when dealing with complex domain logic. The contribution of APF lies in complementing these reasoning-centric frameworks with an engineering-centric closed feedback loop. Rather than treating environmental feedback as mere text to be read, APF introduces aVerifyfunction that transforms state changes into verified knowledge (∆K). This ensures that the agent’s deep reasoning (CoT) is not performed in a vacuum but is grounded in a verified reality. By assetizing results into existing domain knowledge (K), APF provides the structural rigor necessary to tame probabilistic execution into a reliable industrial process. 2.2.3 Tool Use and Reflection: Establishing Reference Points for Incremental Convergence Research such as Reflexion by Shinn et al. [2023] proposed a self-reflection mechanism where agents learn from past failures through linguistic feedback. Similarly, approaches like Toolformer Schick et al. [2023] enable language models to autonomously teach themselves to use external tools through self-supervised experiences. These advancements suggest that agents can be optimized through experience rather than fixed code. However, effective reflection and autonomous tool use require a clear reference point—a grounded model of the world—to define what constitutes a "correct" or "desirable" outcome. Without this, self-reflection risks becoming a subjective loop of misinterpretation, and unguided tool use may lead to unverified or uncontrolled side effects. This study concretizes the necessity of such a reference point through the AVR (Act-Verify-Refine) loop. Specifically, a closed-loop structure is proposed where the agent’s actions and tool invocations are evaluated against the mission goals and domain constraints defined in the AJD. This approach transforms the agent’s adaptation from “vague improvement” into a rigorous process of asymptotic convergence toward requirement satisfaction (R). In this framework, each iteration of the AVR loop reduces the delta between the current state and the requirements, ensuring that the agent’s tool use and subsequent refinements are not random but are steered by the structural rigor of the Agentic Problem Frames. 2.2.4 Multi-Agent Systems: Composing Organizations from Reliable Components Beyond single-agent systems, frameworks such as Generative Agents [Park et al., 2023] and AutoGen [Wu et al., 2024] have explored scenarios where multiple agents collaborate to solve complex problems through natural language dialogue. While recent approaches like ChatDev [Qian et al., 2024] and MetaGPT [Hong et al., 2024] have attempted to structure these interactions using waterfall models or Standardized Operating Procedures (SOPs), they still largely rely on "chat-based" consensus, which often leads to cascading hallucinations and uncontrollable emergent complexity [He et al., 2025]. This study argues that a stable agentic organization cannot be formed by simply connecting conversational agents; it must be composed of rigorously defined engineering components. Drawing on the Single-Responsibility Principle for production-grade agents [Bandara et al., 2025], APF focuses on the internal and external structuring of the unit agent via the Agentic Job Description (AJD). By transforming a stochastic model into a mission-oriented component with distinct jurisdictional boundaries and verifiable interfaces, APF provides the fundamental building blocks required for scalable systems. This transition from unstructured collaboration to structured componentization ensures that the reliability of a larger system is mathematically grounded in the verified performance (S, K ⊢ R) of its atomic units. 5 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT 3 Agentic Problem Frames and Agent Development Specification This section introduces the Agentic Problem Frames (APF), a reinterpretation of Michael Jackson’s classical Problem Frames tailored for modern agentic environments, and the Agentic Job Description (AJD), a foundational specification for agent development derived from the APF. Unlike traditional frameworks for deterministic systems, the APF-AJD framework is designed to systematically accommodate and regulate the inherent stochastic behavior of autonomous agents. By shifting the focus from internal code correctness to the structured interaction between the agent and its environment, this study establishes a systematic engineering methodology to transform probabilistic models into reliable, mission-oriented components. 3.1 Redefining Entities: Job Performer (M ) and Workplace (W ) In traditional software engineering, machine (M ) is conceptualized as a deterministic system that executes fixed logic (S) based on invariant domain knowledge (K) to ensure consistent output. In this paradigm, specifications are static and bound during the design phase. In contrast, an LLM-based agent operates as a stochastic machine performing probabilistic inference. Since these models lack fixed deterministic knowledge of specific domains, their unconstrained actions cannot be considered systematic engineering specifications. Instead, the specification takes the form of a dynamic manifestation appearing only at runtime. This study formalizes the generation of the dynamic specification (S t ) as follows: (E t , C t ) M −→ S t (1) This formula implies that the execution specification (S t ) at timetis the result of the stochastic machine (M) processing an incoming event (E t ) within the jurisdictional boundaries defined by the context (C t ). Here,C t does not merely provide auxiliary information; it functions as a control framework that constrains the machine’s probabilistic reasoning within a predefined professional domain. By anchoring the machine’s behavior through this jurisdictional context, a general-purpose model is transformed into a specialized Job Performer capable of fulfilling specific mission requirements (R). In this framework, the World (W) is no longer a static background but functions as an active Workplace where the Job Performer (M) executes the mission. WhileMis the subject of reasoning, the workplace provides the physical and digital infrastructure to ground this reasoning. Specifically, the workplace performs two core functions: first, it provides the jurisdictional context necessary to generateS t ; second, it produces confirmed knowledge (K t+1 ) by verifying whether the results of actions (A) align with (R). From an agentic engineering perspective, the workplace is concretized into the following sub-domains: •Context and Knowledge Domain (W Context ): This is the “designed domain” that anchors the agent’s probabilistic reasoning. it consists of knowledge databases containing domain-specific facts and manuals, as well as memories of past experiences and success trajectories. Through Retrieval-Augmented Generation (RAG), the workplace injects these materials intoM, enabling the agent to concretize ambiguous user requests into domain-specific execution specifications (S t ). This ensures that the agent’s intent is bounded within the organization’s jurisdictional rules. •Interaction Domain (W Interaction ): This is the “causal or biddable domain” where the agent’s capabilities are projected. While traditional PF primarily addressed rigidly defined input forms and pre-configured external system connections, the agentic workplace shifts toward an active Tool Use paradigm. Here, the workplace functions as a dynamic gateway where the agent projects its functional agency into a vast ecosystem. By leveraging standardized protocols such as the Model Context Protocol (MCP), the agent dynamically invokes external tools to trigger actual state changes. This domain is where abstract specifications (S t ) are operationalized into autonomous tool executions (A). •Verification and Approval Domain (W V erification ): This domain acts as an “epistemological filter” that addresses the inherent opacity of agentic actions. The completion of an action does not automatically signify mission success. The workplace must verify results through mechanisms such as monitoring callbacks (e.g., confirmation emails) or obtaining explicit user confirmations. Through these, the agent transforms uncertain state changes into confirmed knowledge (K t+1 ), forming the foundation for the next stage of the mission. 6 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT 3.2 Governing Agent Execution: Concretized Specification and Verified Knowledge The execution of agentMis more than a simple code invocation; it is a governed state evolution process designed to satisfy requirements (R) in an uncertain environment. To establish a rigorous engineering boundary for this execution, this study adopts the structure of Hoare Logic, prescribing the pre-conditions and post-conditions that must be met to transform a stochastic action into a reliable engineering event: S t AK t+1 (2) 3.2.1 Pre-condition: Concretization of the Execution Specification (S t ) In traditional Problem Frames, an action (A) relies on complete information and logical rules strictly determined during the design phase. However, in an agentic environment, trigger events—whether user requests or external signals—are inherently ambiguous or incomplete. Therefore, before an agent can enter the execution phase, it must undergo a concretization process that synthesizes these ambiguous inputs with the specific workplace context to manifest a clear execution specification (S t ). This manifestation process functions not merely as a supplement to missing information but as a core mechanism for bounding the machine’s reasoning. By anchoring the stochastic machine (M) within the jurisdictional boundaries of a specific job identity, this framework constrains the infinite range of probabilistic outcomes. Through this, the agent evolves from a state of broad capabilities (what it can do) to a precise set of professional tasks (what it must do) within the given context. Consequently,S t serves as a rigorous directive that prevents task drift and ensures that the agent’s behavior remains consistent with its assigned role. 3.2.2 Post-condition: Post-Confirmation of Knowledge (K t+1 ) Traditional engineering assumes that the results of a machine’s execution are reflected in the causal world immediately and deterministically. In an agentic environment, however, the outcomes of an action (A) are often opaque due to the machine’s stochastic nature and the complexity of environmental variables. Therefore, a change in the state of the world is not considered confirmed simply because an action has been completed. Instead, the post-conditionK t+1 must be established through a process of post-confirmation within the verification domain (W V erification ). This verification process serves as an essential bridge between the agent’s internal reasoning and external reality. By monitoring objective feedback, such as digital callbacks or explicit user approvals, the workplace filters raw action results to determine if the state change aligns with the original intent. Only results that pass this confirmation (confirm) stage are solidified as “ground truth” or knowledge (K t+1 ) that the system can safely rely upon. Ultimately, this “knowledge-ification” of results provides the foundational grounding for the next execution cycle. K t+1 does not merely signal the end of a task; it provides the verified context necessary to maintain the continuity and reliability of agentic reasoning. By accumulating these confirmed facts, the agent secures an objective basis for subsequent executions, ensuring reality-based progress toward the requirement (R). 3.3 The AVR Loop: Mechanism for Knowledge Assetization and Convergence In agentic systems, the fulfillment of requirements (R) is not a one-time event but an evolutionary journey of iterative execution. This study formalizes this cycle as the AVR (Act-Verify-Refine) Loop, representing the core mechanism by which a stochastic machine transforms probabilistic execution into verified domain knowledge assets. This process is governed by the following state evolution logic: (E t , C t ) Inject −→ S t =⇒ (S t , W t ) Execute −→ W t+1 =⇒ W t+1 Verify −→ K ∆ =⇒ (K t , K ∆ ) Refine −→ K t+1 (3) 3.3.1 Stage 1: Act (Injection and Realization) The Act stage is a bifurcated process encompassing both the internal manifestation of intent and its external realization. •Injection (Concretization): First, the stochastic machine (M) processes an ambiguous trigger event (E t ) within the jurisdictional context (C t ). This step resolves the inherent incompleteness of the request. By anchoring the event to domain-specific rules and memory, the machine manifests a concrete execution specification (S t ), which is now a rigorous, “bounded” set of directives ready for action. 7 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT •Execution (Realization): OnceS t is manifested, the agent realizes this intent by triggering substantial actions within the workplace (W t ). This point marks the transition where internal specifications are applied to the environment, evolving the world intoW t+1 . WhileW t+1 represents a state change, its engineering significance remains opaque until it is formally verified against the original intent. 3.3.2 Stage 2: Verify (Epistemic Determination of K ∆ ) To resolve execution uncertainty, the system invokes aVerifyfunction to observeW t+1 . This stage serves as an epistemic bridge, extracting incremental knowledge (K ∆ )—confirmed facts yielded through action, such as verified API responses or human feedback. This process provides the grounding necessary to confirm whether the state change aligns with the final mission requirements (R). 3.3.3 Stage 3: Refine (From Knowledge Assetization to K t+1 ) The Refine stage is the heart of knowledge assetization. By integrating the incremental knowledge (K ∆ ) with the existing knowledge base (K t ), the agent establishes an updated state of knowledge,K t+1 . This represents a structural update to the agent’s domain expertise, whereK t+1 functions as a refined “map” of the domain based on the latest execution history. Propagation to the Next Cycle: FromK t+1 toC t+1 The updated knowledge (K t+1 ) is not a passive repository; it is immediately propagated as the jurisdictional context (C t+1 ) for the next execution cycle. By feeding refined knowledge back into the machine, the system ensures that the subsequent specification (S t+1 ) is grounded in the verified reality of the previous step. Through this evolutionary progression, the system asymptotically converges toward the mission goal (R). Engineering Significance: Asymptotic Convergence towardRThe significance of the AVR loop lies in its role as a closed-loop control system that drives asymptotic convergence toward mission requirements (R). Through the evolutionary cycle of action, verification, and knowledge assetization, the epistemic entropy of internal assumptions is systematically reduced, driving the system from initial probabilistic uncertainty toward deterministic mission requirements. Each iteration transforms a general-purpose probabilistic model into a reliable, professional Job Performer, ensuring that cumulative results align with high-level requirements. 3.4 Agentic Requirement Satisfaction Argument In classical Problem Frames, the satisfaction argument (S, K ⊢ R) is established through static proof. This assumes that if a perfect specification (S) and invariant domain knowledge (K) are provided, the requirements (R) can be logically and instantaneously derived at the design stage. However, in an LLM-based agentic environment where actions are stochastic and the world is dynamic, this static logic is insufficient. This study redefines the satisfaction argument as a process of asymptotic convergence driven by the AVR loop. Unlike static proofs, the Agentic Requirement Satisfaction Argument views the fulfillment of requirements as a trajectory of increasing certainty. This argument is formalized as follows: lim t→T S t , K t+1 ⊢ R(4) Equation (4) proves that even with a black-box model, reliability is an emergent property of the cumulative verification process rather than an inherent property of the model itself. In the proposed formulation,S t , K t+1 represents state variables that evolve over timet. The agent incrementally approaches requirement satisfaction through the Act-Verify-Refine (AVR) loop: •Concretization of Intent: To initiate execution, the user’s trigger event is constrained by the current domain context (C t ) to manifest the execution specification (S t ). • Epistemic Resolution: After execution, only results that pass formal verification are solidified and assetized as valid knowledge (K t+1 ). The agent satisfies requirement R through this cumulative sequence of execution and feedback: (S 0 , W 0 ) A 0 −→ K 1 , (S 1 , W 1 ) A 1 −→ K 2 ,·→ K T +1 ⊢ R(5) 8 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT This sequence demonstrates that as the total amount of available knowledge (K) increases, the epistemic uncer- tainty—the gap between the agent’s assumptions and the actual world state—is systematically resolved. Ultimately, at the termination pointT, the evidence accumulated inK T +1 provides the logical basis for the full satisfaction of goalR through asymptotic convergence. 3.5 Structural Mechanisms for Agentic Realization This section concretizes the detailed mechanisms constituting the agentic satisfaction argument by contrasting them with classical Problem Frames. These mechanisms define the engineering requirements for an agent to function not merely as a software module, but as a Job Performer fulfilling missions within a dynamic workplace. 3.5.1 Shared Phenomena (Input): Context Injection (C) In traditional PF, the shared phenomena between the machine (M) and the world (W) are defined as deterministic, completed events (e.g., pressing an elevator button). In this deterministic world, signals lead to immediate execution without room for interpretation. In contrast, shared phenomena in an agentic environment focus on bridging the semantic gap through an active input process: •Existence of a Semantic Gap: Inputs from users are inherently vague intents (e.g., “I’m hungry, take me to a restaurant”). A significant semantic gap exists between the abstract intent in the user’s mind and the concrete actions the machine must execute. • Active Reconstruction via Context Injection: To bridge this gap, the input interface reconstructs the intent by injecting context. This context consists of the essential information required for the agent to manifest a professional execution specification: – Contexts (Domain Knowledge): Real-time domain facts, manuals, and jurisdictional regulations infused through RAG. These anchor the agent’s reasoning within established professional boundaries. –Memory (Experience): Re-injection of verified trajectories (K ∆ ) from previous cycles. This provides an empirical basis for the agent, ensuring it learns from its own operational history and avoids repetitive errors. –Capabilities (Competency): Technical specifications and constraints of available tools (e.g., MCP). This deterministically limits the scope of the agent’s behavioral power to what is actually feasible in the workplace. •Realization into Execution Specification (S t ): Through the integration of these contextual dimensions, uncertain intent is transformed into a concrete, executable specification. The core of requirement satisfaction lies in this input-stage realization, where the machine accurately interprets the what and how of the mission, manifesting a bounded execution specification (S t ) before proceeding to action. 3.5.2 Shared Phenomena (Output): The Epistemic Bridge via Callback and Confirm In an agentic environment, a fundamental dependency asymmetry exists between the agent’s action (A) and the world’s reaction. While the machine attempts to change the world, the world does not inherently report the outcomes back into the machine’s logical system. This study defines theVerifyfunction as an epistemic bridge to bridge this gap, concretized through a dual-channel of Callback (Fact Verification) and Confirm (Value Verification). Our design extends the concept of Atomic Action Pairs [Thompson, 2025]. While Thompson’sGuardfunctions focus on defensive filters to prevent workflow contamination, ourVerifyfocuses on solidifying any execution result into reliable knowledge (K t+1 ). Even a failure, once confirmed as knowledge, is fed back as a contextual asset (C t+1 ) for the next execution, enhancing system adaptability. •Callback (Fact Verification): A process to synchronize the states of the machine and the world by identifying physical or digital changes. It serves as a lifeline that grounds the agent’s reasoning in reality. – Explicit Callback: Feedback received via paths designed for machine communication (e.g., API re- sponses, Webhooks). –Implicit Callback: In legacy environments without formal paths, the agent detects environmental side-effects (e.g., visual recognition of an elevator’s floor display). •Confirm (Value Verification): This procedure finalizes whether the physical facts identified via callback align with the user’s business value and intent. This is achieved through a chain of governance, following the principle that "the executor does not approve their own work." Whether through a human-in-the-loop or a 9 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT separate critic agent, this final approval ensures knowledge finalization, where only confirmed results are recognized as valid knowledge (K t+1 ) for satisfying requirements (R). 3.5.3 Inverse Design and Assetization The APF favors an inverse design approach, prioritizing the refinement of external control mechanisms over internal model modification. • External Control Primacy: This study prioritizes bounding and controlling model behavior through the design of external context (C) and verification (V). Rather than modifying the model’s internal parameters, the author focuses on engineering a rigorous environment that steers the stochastic machine toward reliable outcomes. •Knowledge Assetization and the Data Flywheel: Results generated through the agentic loop are transformed into high-quality knowledge assets. The sequences ofS t AK t+1 constitute verified trajectories that have passed the Confirm stage. These trajectories are fed back into the domain knowledge base (K) and jurisdictional context (C). This forms a data flywheel—a virtuous cycle where accumulated operational experience refines the “ground truth” available to the agent, thereby ensuring higher precision and continuous reliability in future execution cycles. 3.6 Agentic Job Description: Engineering Specification for Job Performers The Agentic Job Description is the final engineering output of the APF framework, serving as a systematic specification for agent development. In this study, the AJD is conceptualized as a formal contract between the organization and the agent. This is analogous to a manager assigning a mission to a new employee; to ensure successful performance, the manager must clearly define the mission, the boundaries of authority, the available resources, the professional context to reference, and the explicit criteria for evaluation. 3.6.1 The AJD as a Blueprint for Specialized Roles The engineering significance of the AJD lies in its ability to transform a general-purpose stochastic machine (M) into a reliable Job Performer by defining its operational boundaries within the workplace (W). The AJD Table (Table 1) functions as a design blueprint that implements the core philosophy of Problem Frames through the following perspectives: • Defining Authority and Jurisdiction (Scope & Workplace): Just as a new employee must know their department and reporting line, the AJD defines the machine’s identity (M) as a professional job performer and its interaction targets within the world (W). It establishes jurisdictional boundaries—explicitly stating what the agent is authorized to do and, more importantly, what it is forbidden to do. This implements PF’s focus on defining domain characteristics to ensure the agent’s behavior is bounded within professional limits. •Structuring Informational Reference (Operational Context): No employee can perform effectively without the right information. The AJD formalizes the "reference materials” required for the job. It defines how vague user intents are concretized into execution specifications (S t ) by injecting real-time manuals (context) and previous success trajectories (memory). This ensures that the agent’s reasoning is always grounded in the specific workplace reality rather than general probabilistic guessing. •Defining Evaluation and Accountability (Evaluation Method): In a formal contract, performance is not judged by effort but by results. The AJD prescribes the "epistemic bridge"—the specific callback and confirmation criteria—that must be met to finalize a task. This ensures that the agent’s output is verified against objective evidence in the world, satisfying the Agentic Requirement Satisfaction Argument through proven facts. To bridge the gap between abstract engineering and practical organizational design, the AJD components are mapped to the essential elements of a professional job contract for a new employee. Within this framework, Mission (R) represents the final goal, explicitly defining the specific outcomes and value expected from the role rather than mere task lists. The Workplace (W) identifies the office and environment, specifying the systems, digital tools, and departments the agent is authorized to interact with. The Scope (M) functions as a definition of authority and ethics, establishing the agent’s professional title and, crucially, the "no-go" zones or negative constraints that bound its behavior. For successful execution, the Operational Context (S) serves as the handbooks and experience, providing the manuals to be followed and the historical cases to 10 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT be referenced during reasoning. Finally, the Evaluation Method (K) is conceptualized as the performance review, prescribing the objective evidence and verification procedures required to prove the task has been satisfied according to professional standards. Table 1: Mapping Components of the AJD AJD Com- ponent PF MappingEngineering Guidelines & Implementation Points MissionRequirement (R) The final goal state to be achieved in the world (W ). [Result-Oriented] Focus on "What" rather than "How." •Define the goal state (e.g., "Prevent accident" instead of "Stop equipment") to allow for reasoning autonomy. WorkplaceWorld (W )Physical/digital domains the machine interacts with. [Domain Isolation] Distinguish if the domain is Causal (API) or Biddable (User). • Define isolated side-effect boundaries for W User , W Motor , etc. ScopeMachine (M ) Identity and jurisdictional boundaries of the machine. [Machine’s Authority] Specify permissions and negative constraints. •Use guardrails to prevent hallucinations and job deviation from the profes- sional persona. Operational Context Spec (S)Information required to transform events into execution specifications (S t ). [Late Binding] Inject the following at runtime: • Contexts: Real-time domain knowledge (RAG) and Scope/Authority boundaries. • Memory: Re-injection of verified success trajectories (K ∆ ). • Capabilities: Tool specifications (MCP/A2A). Evaluation Method Knowledge (K) Epistemic confirmation procedures to prove mission completion. [Epistemic Grounding] Design logic to finalize action results as knowledge: • Callback: Fact verification (Physical/Digital sensor data). • Confirm: Value verification (Explicit user approval). 4 Case Study: Engineering a Reliable Job Performer The purpose of these case studies is to demonstrate how the Agentic Job Description serves as an engineering blueprint to transform human tasks into reliable agentic operations. Rather than simply documenting system requirements, the AJD provides a comprehensive design for delegating authority to a stochastic machine, ensuring that its autonomous judgment consistently aligns with organizational goals. Two distinct scenarios are presented to illustrate this transformation. First, the delegated proxy model, where the agent acts as a professional assistant navigating complex information systems to resolve ambiguous human intents. Second, the autonomous supervisor model, where the agent functions as a field manager in a physical environment, making independent decisions to maintain system integrity. Each case illustrates the complete lifecycle of agentic engineering: from modeling the interaction between the performer (M) and its workplace (W), to defining the boundaries of autonomous judgment that satisfy high-level requirements (R). By tracing the agent’s journey through these scenarios, this study demonstrates how the AJD framework transforms a general-purpose probabilistic model into a specialized, mission-oriented professional. 4.1 Case 1: Smart Business Travel Assistant (Delegated Proxy Model) The Smart Business Travel Assistant represents a quintessential delegated proxy agent that receives delegated vague intent from a user and performs tasks within the information system domain. The core of this model lies in bridging the semantic gap between the user and the system while minimizing the cognitive cost incurred during complex booking processes. In this case, the agent’s mission extends beyond simple administrative support; it aims to fundamentally eliminate the decision fatigue that employees experience during business travel preparation. By harmonizing corporate regulations with personalized convenience to propose optimal itineraries, the agent functions as a cognitive partner, fostering an environment where employees can remain fully immersed in their core professional responsibilities. 11 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT To transform a user’s abstract event, such as “Prepare for my business trip to Busan next week,” into a rigorous execution specification (S t ), the AJD presented in Table 2 is formulated. Table 2: AJD Specification for Smart Trip Assistant AJD ItemPF MappingEngineering Specification (S) MissionRequirement (R) [Minimize Administrative Effort] Minimize direct user intervention and cog- nitive effort by providing a completed itinerary through personalized scheduling and autonomous reservation. WorkplaceWorld (W ) • W User : Subject of request and the final value approval domain. • W System : Internal email systems, groupware (calendars), etc. • W External : Airlines, railway systems, and hotel reservation APIs. ScopeMachine (M ) •[Identity]: Senior-level professionalism with deep awareness of corporate travel policies. • [Authority]: Permission for temporary bookings and submission of payment drafts within corporate limits. •[Boundary]: Strict blocking and warning for policy violations (e.g., unautho- rized Business class). Operational Context Spec (S) • Contexts: Meeting schedules and corporate travel reimbursement guidelines. •Memory: Historical preferences (e.g., H-hotel in Haeundae or a preferred window seat). • Capabilities: Real-time API integration for transport and accommodation via MCP. Evaluation Method Knowledge (K) • Callback: Fact-checking by monitoring email for e-ticket/voucher issuance. • Confirm: Acquisition of explicit final approval from the user on the proposed itinerary. 4.1.1 Domain Modeling via APF Diagram Figure 1 presents the APF diagram for the Smart Business Travel Assistant, serving as a blueprint for the interaction between the performer and its workplace. While maintaining Michael Jackson’s traditional notation, the diagram differentiates visual elements to reflect the agent’s characteristics as a stochastic yet bounded entity. •Agent Instance (M): The agentM, the core of the design, is highlighted with a double line. This signifies that the machine is not merely a computational artifact but an independent performing subject with a job identity and jurisdictional boundaries defined by the AJD. •Biddable Domain (W User ): The user, represented by a dashed line, is the subject of delegation and value confirmation. This notation specifies that the user’s intent is a flexible domain that must be synchronized through dialogue and final approval. • Causal Domains (Airline/Hotel/Mail Systems): Systems that react deterministically via APIs or protocols (e.g., MCP) are represented by solid lines. These are targets upon which the agent’s capabilities are projected to satisfy the requirement (R). •The Verification Channel (Mail System): A unique feature of this model is the use of the Mail System as an implicit callback channel. By monitoring the arrival of e-tickets and vouchers, the agent performs fact verification, grounding its logical state in the physical reality of the booking outcome. 1 4.1.2 Scenario-based Specification Refinement (S t Transformation) A short utterance from a user, such as “Prepare for my business trip to Busan next week,” is a typical incomplete event (E t ). At this juncture, the Smart Business Travel Assistant demonstrates its professional expertise by performing the transformation: (C t , E t ) Inject −→ S t . 1 Solid arrows denote direct interactions between the machine and world domains, including requests, intent delegation, and confirmation requests to the user; dotted arrows signify callbacks for notifications or information collection from the world; and dashed arrows represent the flow of information, such as context injection and information transfer between external domains. 12 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT R: Minimal Effort Journey (Personalized Optimization & Booking Completion) <<Biddable>> User [W_User] <<Causal>> Airline System <<Causal>> Hotel System <<Agent Instance>> Smart Travel Agent [M] MCP: Flight Action MCP: Room Action Intent Delegation & Confirm (Value Verification) <<Operational Context [S]>> - Contexts: Policies & Status - Memory: Past Experience - Capabilities: MCP/A2A Tools Context Injection (Memory & Capabilities) <<Causal>> Mail System (Verification Channel) Send E-TicketSend Voucher Implicit Callback (Fact Verification) Figure 1: APF diagram for industrial smart travel agent The process begins with Context Injection, where the agent, upon receiving the “Busan” keyword, refers to corporate travel regulations (e.g., lodging caps, transportation classes) via the Contexts layer. Simultaneously, it checks external environments—such as large-scale conferences in Busan—to recognize inflated hotel prices and explore optimal alternatives within regulations. This is followed by Memory Retrieval, which searches through successful past trajectories to automatically reflect personalized preferences, such as preferred rail seat orientations or specific hotel brands, into the specification. Finally, Capabilities Action is triggered, where the refined specification (S t ) invokes MCP-based APIs for airlines, railways, and hotels to perform provisional bookings. This stage moves beyond mere inquiry to realize the essence of delegated booking by organically linking internal payment systems with external APIs. 4.1.3 Epistemic Verification and Assetization In this scenario, the verification procedure is operated concisely, aiming for minimum intervention to reduce the user’s cognitive load. The agent undergoes a callback procedure to synchronize its state with physical reality by monitoring the arrival of vouchers and e-tickets from the booking systems. The loop is closed by obtaining the user’s confirm (value approval) for the final proposed itinerary. Once confirmed, this successful execution trajectory (K ∆ ) is fed back into the experience memory. It becomes a core knowledge asset that enables a higher level of automation for future requests, allowing the agent to anticipate needs without requiring explicit instructions. In conclusion, the Smart Business Travel Assistant functions as a proactive agent that minimizes the user’s administrative effort through 13 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT intelligent context integration, simultaneously satisfying both individual convenience and organizational regulations with minimal intervention. 4.2 Case 2: Industrial Equipment Manager (Autonomous Supervisor Model) The Industrial Equipment Manager represents a quintessential autonomous supervisor model. This agent monitors real-time data from physical sites, independently assesses anomalies, takes immediate corrective actions, and is subsequently evaluated for the appropriateness of its decisions. Unlike the delegated proxy model, this system focuses on fulfilling missions based on the Act-then-Report principle, where timely intervention in physical environments precedes human approval. To integrate immediate physical control with high-level cognitive judgment, this case employs a nested structure. This architecture combines an edge agent (fast loop) operating at the core of the equipment for low-latency responses, and a central agent (slow loop) that coordinates overall operations and long-term optimization. 4.2.1 AJD Specification for the Industrial Equipment Manager The professional expertise and jurisdictional boundaries of the Equipment Manager are defined in the AJD specification presented in Table 3. Table 3: AJD Specification for Industrial Safety Agent AJD ItemPF MappingEngineering Specification (S) MissionRequirement (R) [Optimize Safety and Uptime] Maintain an absolute safe state at all times while minimizing unplanned downtime through proactive intervention and rapid reporting. WorkplaceWorld (W ) • W Edge : IoT Edge Agent (Intermediary for real-time sensing and control). • W Digital : ERP and maintenance management systems (Parts ordering and report storage). • W Manager : On-site safety and production managers (Final approvers). ScopeMachine (M ) •Authority: Detection of anomalies, emergency intervention (Edge control), root cause analysis, and drafting action reports. •Constraint: Prohibition of unauthorized restarts and final payment for parts without manager approval. Operational Context Spec (S) •Contexts: Equipment specifications, safety regulations, and failure diagnosis manuals. • Memory: Historical failure patterns and successful response trajectories. •Capabilities: A2A-based Edge communication and ERP system API integra- tion. Evaluation Method Knowledge (K) •Callback: Physical verification of action results (e.g., confirming RPM=0 via sensor data). •Confirm: Assetization of knowledge through final approval of parts orders and root cause analysis reports. 4.2.2Domain Modeling and Scenario Analysis Figure 2 presents the APF diagram for the Industrial Equipment Manager. The diagram illustrates a nested loop architecture where the agent instance is decomposed into specialized roles to satisfy requirements in both physical and digital domains. •Hierarchical Agent Entities (M): The agent is modeled as a dual-entity system. The IoT Edge Agent (Reflex) handles the "Fast Loop," interacting directly with Physical Equipment (Causal Domain) via sensing and reflex stop. The Central Safety Agent (Supervisor) manages the "Slow Loop," performing high-level reasoning and reporting. •The Reporting Chain (Biddable Domain): The Site Manager, represented as a biddable domain, provides final confirm (Value Verification). This ensures that the agent’s autonomous decisions are validated and recorded as organizational knowledge. 14 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT R: Safe & Optimized Operation (Zero-Harm & Minimal Downtime) <<Biddable>> Site Manager [W_Manager] <<Causal>> Physical Equipment <<Causal>> ERP System (Parts & Assets) <<Machine: Supervisor>> Central Safety Agent [M] (Slow Loop) <<Machine: Reflex>> IoT Edge Agent [M] (Fast Loop) Config Thresholds 3. Submit Root Cause Report & Parts Order Request 4. Confirm & Approve (Value Verification) 5. Execute Parts Order 2. Anomaly Notification (Implicit Callback) <<Operational Context [S]>> - Contexts: Safety Manuals - Memory: Past Failure Patterns - Capabilities: Diagnosis & Reporting Context & Memory (Root Cause Analysis) 1. Sensing & Reflex Stop Status Figure 2: APF diagram for industrial safety manager agent •Causal Interaction (ERP System): The agent projects its capabilities onto the ERP system to execute parts orders, organically linking safety management with business operations. The Industrial Equipment Manager demonstrates its professional expertise through the following scenario-based transformation: • Anomaly Detection and Immediate Intervention: Upon receiving vibration and temperature anomaly data (E t ) from the IoT Edge Agent, the Central Agent diagnoses risks by cross-referencing its injected Context and Memory. If the potential for damage exceeds a predefined threshold, the agent exercises its jurisdictional authority to immediately halt the equipment via W Edge , preventing catastrophic accidents. • Analysis and Report Generation: Following intervention, the agent transitions to a reflective stage. It performs root cause analysis, identifies necessary replacement parts, and submits a requisition through the ERP system, preparing follow-up processes to minimize downtime. •Value Confirmation and Assetization: A field manager reviews the report and provides final approval. This Confirm step is a process of epistemic grounding that validates the agent’s judgment. Once approved, the response trajectory is fed back into the experience memory, enabling higher precision in future diagnostics. 5 Discussion This study extends the traditional Software Engineering (SE) Problem Frames (PF) into agentic environments, proposing a structural foundation to transform stochastic models into reliable engineering components for industrial sites. Beyond 15 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT the general value alignment of AI, this section discusses the specific principles of control and operation required for an agent to function as a “trusted colleague” within a specific domain. 5.1 From Abstract Quality to Concrete Control through Bounding While existing Requirements Engineering for AI (RE4AI) and alignment research have focused on “universal and abstract qualities” such as fairness and ethics, the APF proposed in this study addresses quality as an engineering component that is immediately composable and deployable within a specific domain. In industrial settings, the reliability required of an agent does not depend on the vague level of its intelligence, but on how strictly it fulfills a given mission. To achieve this, APF provides concrete control through input/output bounding as follows: • Dynamic Concretization of Input Specification: Instead of relying on the infinite knowledge of the internet, the agent is constrained to reason within the closed boundaries of domain knowledge (W Context ) defined by the AJD. Ambiguous natural language requests are transformed into concrete execution specifications (S t ) within these boundaries, serving as an engineering fence that prevents the stochastic wandering of intelligence. •Assetization and Feedback of Execution Results: An agent’s execution does not end with completion. Incremental knowledge (∆K) derived through verification (W V erification ) refines the domain knowledge, which is then fed back as the input context for subsequent executions. Through this process, the agent evolves into a reliable component that asymptotically converges toward the requirements (R) over time. Recent findings by Huang et al. [2025] indicate that developers prefer explicit control through context injection and result verification over the vague creativity of AI. Furthermore, Kurshan et al. [2025] emphasized the necessity of self-regulation blocks that can intervene in model execution paths to ensure the safety of financial AI. The APF architecture is a direct result of incorporating these industrial requirements into a formal framework. 5.2 Clarifying Accountability: From Model Errors to Managerial Responsibility When a general-purpose agent produces an incorrect result, the public often attributes the error to the “AI’s mistake,” shifting accountability into the opaque black box. However, in an APF-based domain agent environment, the locus of accountability must be redefined as a matter of the adequacy of context injection and specification. Viewing the agent as a professional Job Performer, failures can be explained through the following distinct engineering perspectives: • Insufficient Jurisdictional Context: The failure to provide the necessary information required for execution. •Knowledge Mismatch: The injected domain knowledge was inconsistent with reality, leading to the generation of flawed input specifications (S t ). •Deficient Criteria: The failure to define objective success conditions required to verify and evaluate mission fulfillment. Ultimately, the issue of agent accountability shifts from a psychological inquiry (e.g., “Why did the AI misjudge?”) to a managerial and engineering responsibility (e.g., “Did the system provide sufficient authority, context, and clear evaluation criteria for the agent to complete the mission?”). This approach moves away from the irresponsibility of blaming the black box and provides a practical metric for accountability based on compliance with specification and verification procedures. 5.3 Redefining Operation: Adaptation through Reality Sync This study redefines the operation of agentic systems as a continuous process of managing the gap between the machine’s (M) internal “assumptions about the world” and the ever-changing “reality.” Since the underlying foundation models provide only universal reasoning capabilities, real-time field information must be continuously injected into the agent’s context to satisfy specific industrial requirements over time. In this process, the post-verification procedure functions beyond a simple pass/fail assessment; it acts as a critical sensor detecting changes in the physical or digital world. Detected environmental shifts immediately update the knowledge base linked to the AJD, allowing the agent to flexibly adapt to changing realities through updated context without requiring a separate retraining process. 16 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT Consequently, the true essence of agentic engineering lies not in increasing the “size” of intelligence, but in how robustly one structures the grounding upon which the agent stands, and how up-to-date that grounding is maintained through the loop of execution and verification. The APF and AJD proposed in this study serve as the minimum specifications and protocols that enable such engineering control. This perspective aligns with contemporary research. Hu et al. [2026] emphasized the growth of context (C) through the evolution of experience memory, while Schick et al. [2023] demonstrated tool-use optimization via Toolformer, and Shinn et al. [2023] proved the possibility of machine learning through self-reflection in Reflexion. While these efforts enhance agent adaptability at different layers, the APF provides the architectural foundation where these individual technologies can orderly converge toward the engineering goal of “Requirement Satisfaction.” 6 Conclusion This research proposes the Agentic Problem Frames as an engineering foundation for transforming general intelligence into a trusted “colleague” within specific domains. Moving beyond the conventional view of agents as opaque, intelligent black boxes, this study redefines them as independent, composable engineering components that can be integrated into complex organizational systems. The most pivotal differentiation established in this research lies in the paradigm of specification. Unlike traditional software that relies on fixed logic, specifications for stochastic machines like agents cannot be finalized at the design stage. Instead, the author presents a dynamic specification (S t ) paradigm, where ambiguous natural language requests are synthesized with domain knowledge (K) to manifest as concrete directives just before execution. To guide the agent’s probabilistic reasoning toward deterministic requirement satisfaction (R), the proposed framework internalizes the AVR (Act-Verify-Refine) feedback loop as an architectural device. This loop enables the assetization of execution results by verifying outcomes and re-injecting them as context for subsequent iterations. Through this structural control, reliable unit agents—governed by clear Agentic Job Description—can be composed into higher-order systems capable of executing the large-scale, complex missions of an organization. In conclusion, the reliability of agents in industrial settings stems not from the model’s intelligence (IQ), but from the engineering structuring that refines knowledge through repeated execution and verification. This study formalized this essential convergence process with the following equation: lim t→T S t , K t+1 ⊢ R This formula proves that when the specification (S t ) at each time step is continuously calibrated by verified knowledge assets (K t+1 ), the agent inevitably reaches the point of trust (R). The author expects the framework presented in this study to serve as a robust milestone, grounding agents as legitimate members of the industrial workforce rather than mere technological novelties. Call for Collaboration: Empirical Validation The author is actively seeking partners to apply the proposed APF and AJD frameworks to complex, real-world industrial domains to further validate their efficacy. I welcome researchers and practitioners who wish to implement agents as composable components to achieve organizational missions or to empirically validate the process of incremental requirement satisfaction within their own domains. Contact: [calling6@snu.ac.kr] References Ruanqianqian Huang, Avery Reyna, Sorin Lerner, Haijun Xia, and Brian Hempel. Professional software developers don’t vibe, they control: AI agent use for coding in 2025. arXiv preprint arXiv:2512.14012, 2025. URLhttps: //arxiv.org/abs/2512.14012. Michael Jackson. Problem Frames: Analysing and Structuring Software Development Problems. Addison-Wesley, 2001. Pamela Zave and Michael Jackson. Four dark corners of requirements engineering. ACM Trans. Softw. Eng. Methodol., 6(1):1–30, January 1997. ISSN 1049-331X. doi:10.1145/237432.237434. URLhttps://doi.org/10.1145/ 237432.237434. 17 Agentic Problem Frames: A Systematic Approach to Engineering Reliable Domain Agents A PREPRINT Michael Jackson. Problem structure and dependable architecture. In Workshop on Architecting Dependable Systems (WADS) at ICSE 2004, 2004. Jan Bosch, Helena Holmström Olsson, and Ivica Crnkovic. Engineering AI systems: A research agenda. In Artificial Intelligence in Software Engineering. Springer, 2021. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed H. Chi, Quoc V. Le, and Denny Zhou. Chain-of-thought prompting elicits reasoning in large language models. In Proceedings of the 36th International Conference on Neural Information Processing Systems, NIPS ’22, Red Hook, NY, USA, 2022. Curran Associates Inc. ISBN 9781713871088. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. ReAct: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629, 2023. URLhttps://arxiv.org/ abs/2210.03629. Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: language agents with verbal reinforcement learning. In Proceedings of the 37th International Conference on Neural Information Processing Systems, NIPS ’23, Red Hook, NY, USA, 2023. Curran Associates Inc. Timo Schick, Jane Dwivedi-Yu, Roberto Dessí, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: language models can teach themselves to use tools. In Proceedings of the 37th International Conference on Neural Information Processing Systems, NIPS ’23, Red Hook, NY, USA, 2023. Curran Associates Inc. Joon Sung Park, Joseph C. O’Brien, Carrie J. Cai, Meredith Ringel Morris, Percy Liang, and Michael S. Bernstein. Generative agents: Interactive simulacra of human behavior. In In the 36th Annual ACM Symposium on User Interface Software and Technology (UIST ’23), UIST ’23, New York, NY, USA, 2023. Association for Computing Machinery. Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang (Eric) Zhu, Li Jiang, Xiaoyun Zhang,Shaokun Zhang,Ahmed Awadallah,Ryen W. White,Doug Burger,and Chi Wang.Autogen:Enabling next-gen LLM applications via multi-agent conversation.In COLM 2024,August2024.URLhttps://w.microsoft.com/en-us/research/publication/ autogen-enabling-next-gen-llm-applications-via-multi-agent-conversation-framework/. Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, Juyuan Xu, Dahai Li, Zhiyuan Liu, and Maosong Sun. ChatDev: Communicative agents for software development. arXiv preprint arXiv:2307.07924, 2024. URL https://arxiv.org/abs/2307.07924. Sirui Hong, Mingchen Zhuge, Jiaqi Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. MetaGPT: Meta programming for a multi-agent collaborative framework. arXiv preprint arXiv:2308.00352, 2024. URL https://arxiv.org/abs/2308.00352. Junda He, Christoph Treude, and David Lo. LLM-based multi-agent systems for software engineering: Literature review, vision, and the road ahead. ACM Trans. Softw. Eng. Methodol., 34(5), May 2025. ISSN 1049-331X. doi:10.1145/3712003. URL https://doi.org/10.1145/3712003. Eranga Bandara, Ross Gore, Peter Foytik, Sachin Shetty, et al. A practical guide for designing, developing, and deploying production-grade agentic AI workflows. arXiv preprint arXiv:2512.08769, 2025. URLhttps://arxiv. org/abs/2512.08769. Matthew Thompson. Managing the stochastic: Foundations of learning in neuro-symbolic systems for software engineering. arXiv preprint arXiv:2512.20660, 2025. URL https://arxiv.org/abs/2512.20660. Eren Kurshan, Tucker Balch, and David Byrd. The agentic regulator: Risks for ai in finance and a proposed agent-based framework for governance. arXiv preprint arXiv:2512.11933, 2025. URLhttps://arxiv.org/abs/2512.11933. Yuyang Hu, Shichun Liu, Yanwei Yue, Guibin Zhang, Boyang Liu, Fangyi Zhu, Jiahang Lin, Honglin Guo, Shihan Dou, Zhiheng Xi, Senjie Jin, Jiejun Tan, Yanbin Yin, Jiongnan Liu, Zeyu Zhang, Zhongxiang Sun, Yutao Zhu, Hao Sun, Boci Peng, Zhenrong Cheng, Xuanbo Fan, Jiaxin Guo, Xinlei Yu, Zhenhong Zhou, Zewen Hu, Jiahao Huo, Junhao Wang, Yuwei Niu, Yu Wang, Zhenfei Yin, Xiaobin Hu, Yue Liao, Qiankun Li, Kun Wang, Wangchunshu Zhou, Yixin Liu, Dawei Cheng, Qi Zhang, Tao Gui, Shirui Pan, Yan Zhang, Philip Torr, Zhicheng Dou, Ji-Rong Wen, Xuanjing Huang, Yu-Gang Jiang, and Shuicheng Yan. Memory in the age of AI agents. arXiv preprint arXiv:2512.13564, 2026. URL https://arxiv.org/abs/2512.13564. 18

Instant research discovery