A Pattern Language for Resilient Visual Agents Integrating advanced AI models into enterprise software creates a difficult architectural trade-off. On one side, traditional automation tools are fast and reliable but break easily when a user interface changes. On the other side, modern Vision Language Action (VLA) models are highly adaptable and smart, but they are too slow, expensive, and unpredictable for real-time enterprise tasks. This paper proposes a new architectural framework that bridges this gap by separating an agent’s "reflexes" from its "reasoning," allowing systems to be both fast and intelligent. The Dual-Layer Approach The authors suggest that visual agents should be designed like embodied robots rather than simple scripts. By adopting a hierarchical structure, the agent functions through two distinct layers: System 1 (Reflex Layer): A fast, deterministic layer that handles routine tasks in milliseconds using cached visual templates. System 2 (Supervisor Layer): A slower, more powerful cognitive layer that uses VLA models to plan, recover from errors, and update the reflex layer when the interface changes. This design ensures that the agent only uses expensive, high-latency AI reasoning when it encounters something it does not recognize, such as a button moving or changing color. Four Patterns for Resilience To implement this architecture, the paper introduces four specific design patterns that help developers organize their systems: 1. Hybrid Affordance Integration: Combines different sensory inputs (like text and object detection) to ensure the agent doesn't get confused by "hallucinations" or non-functional UI elements. 2. Adaptive Visual Anchoring: Acts as a bridge between the fast reflex layer and the slow supervisor. If the reflex layer loses confidence in a UI element, it triggers the supervisor to find the new location and update the cache. 3. Visual Hierarchy Synthesis: Organizes flat screen data into a logical structure (like forms or tables). This allows the agent to understand relationships between elements, making it more robust to layout shifts. 4. Semantic Scene Graph: Creates a queryable map of the interface. This allows the agent to verify safety and context before taking an action, which is critical for preventing errors in sensitive enterprise environments. Balancing Performance and Cost The primary advantage of this architecture is "amortized inference." Because the agent relies on its fast reflex layer for the vast majority of its work, the high cost and latency of the VLA model are spread out over thousands of successful interactions. In a test scenario involving a UI change, the proposed architecture successfully identified the shift, prevented a potentially dangerous action (clicking the wrong button), and updated its internal model to continue working at high speeds. Key Takeaways This approach moves agent design away from "open-loop" scripts—which blindly follow instructions—toward "closed-loop" systems that can perceive, analyze, and correct themselves. By formalizing these patterns, the authors provide a roadmap for building enterprise agents that are stable enough for industrial use while remaining flexible enough to handle the dynamic nature of modern software interfaces.