Technical Summary: Organizational Memory for Agentic Business Process Execution

Problem Statement

While Large Language Model (LLM)-based agents offer new capabilities for automating complex, multi-step business processes beyond the limits of rule-based systems (e.g., RPA), they face a critical scalability barrier in enterprise settings: the lack of organization-specific knowledge. General-purpose LLMs are not inherently aware of company policies, process conventions, role structures, or exception-handling practices.

Current approaches attempt to bridge this gap by encoding specific knowledge into individual agent prompts or retrieval setups. However, the authors argue this does not scale in large organizations. Creating per-agent knowledge leads to:

• Knowledge Silos: Rules are duplicated across thousands of agents.
• Inconsistency: Updates are applied unevenly, leading to conflicting interpretations.
• Maintenance Burden: Learning and policy updates cannot be propagated efficiently.
• Fragmentation: Relevant knowledge exists in heterogeneous, human-oriented artifacts (BPMN models, SOPs, policies, ERP documentation) that are not structured for agent consumption.

The core challenge is not knowledge availability, but transforming fragmented, human-centric knowledge into a unified, agent-consumable form that can be consistently provided to all agents while evolving with organizational changes.

Methodology and Architecture

The paper proposes Organizational Memory: a shared, human-governed, and agent-consumable reference layer of procedural knowledge. The architecture is divided into two complementary phases: Memory Curation and Memory Consumption.

1. Core Design: Process Atoms

Instead of storing raw documents or large text chunks, the architecture decomposes knowledge into Process Atoms. Each atom is a self-contained unit capturing exactly one rule, constraint, or responsibility. An atom consists of:

• Name: A short identifier for the behavior.
• Source: A reference to the original artifact (e.g., specific section of a policy).
• Content: A structured description with three parts:
  • Applicability: Context (process, role, object, precondition).
  • Action: The specific rule or required behavior.
  • Purpose: The rationale for the rule.
• Tags: Grounding the atom in an Enterprise Domain Model (e.g., "procurement," "purchase requisition") to enable context-aware retrieval.

2. Memory Curation (Creation & Maintenance)

This phase transforms heterogeneous sources into the unified memory:

• Input: Policies, SOPs, process models, system documentation, and execution traces.
• Extraction: Source-specific services extract candidate atoms and ground them with domain tags.
• Global Curator: An active entity that performs:
  • Quality Checks: Ensuring atoms have clear scope and single rules.
  • Conflict Detection: Identifying overlaps, redundancies, or contradictions with existing memory.
• Human Governance: A human expert reviews the proposed changes (additions, removals, modifications) and resolves conflicts. This ensures accountability and that the memory reflects organizational intent.

3. Memory Consumption (Runtime)

This phase serves agents during process execution:

• Context Request: The agent sends a request describing the current task context (process, activity, role, input data).
• Retrieval: A Retriever component queries the memory. It uses a hybrid approach:
  • Filtering: Using domain tags to narrow the scope (e.g., specific subsidiary or role).
  • Selection: Using semantic or LLM-based selection within the filtered set to find the most relevant atoms.
• Execution: The agent receives a compact set of relevant atoms (not full documents) to guide its decision-making.

Key Contributions

The paper makes four primary contributions:

1. Concept Definition: Introduces "Organizational Memory" as a unified representation of organizational process knowledge, distinct from individual agent prompts or local memories.
2. Requirements Derivation: Defines nine specific requirements for such a system, including integration of heterogeneous sources, atomic decomposition, conflict detection, traceability, context-specific retrieval, low-latency access, adaptive evolution, human governance, and scalability.
3. Architecture Proposal: Presents a detailed architecture covering the curation (extraction, conflict resolution, human review) and consumption (contextual retrieval) phases, centered on the "Process Atom" abstraction.
4. Proof-of-Concept: Demonstrates the architecture's effectiveness in a procurement scenario.

Experimental Results

The authors conducted a proof-of-concept using a synthetic "Purchase-to-Pay" scenario with an LLM-based agent acting as a procurement assistant.

• Setup: Three configurations were tested:
  • Base: No organizational knowledge.
  • RAG: Standard Retrieval-Augmented Generation using vector embeddings of document chunks.
  • Memory: Access to the proposed Organizational Memory (Process Atoms).
• Models: Tested on GPT-4.1 and Claude Sonnet 4.5.
• Metric: Policy Compliance Rate (PCR) – the fraction of scenarios where the agent correctly created or refused a purchase requisition based on policy.
• Findings:
  • Base: 30% compliance (failed to apply rules not in parametric knowledge).
  • RAG: 70–80% compliance. Improved over Base but failed on "cross-cutting" rules (e.g., universal cost center requirements) that were not semantically close to the specific request.
  • Memory: 88–95% compliance. The highest performance. By retrieving task-relevant atoms rather than just semantically similar text chunks, the agent successfully applied both specific and general constraints.
• Limitations Observed: Errors in the Memory setup were primarily "over-restrictions" caused by imprecisely extracted atoms (e.g., applicability scope too broad), highlighting that curation quality is critical.

Significance and Claims

The paper claims that reliable and scalable agentic process execution requires moving beyond agent-specific prompts to a shared organizational memory.

• Scalability: The architecture addresses the enterprise challenge of maintaining consistent knowledge across thousands of agents and heterogeneous processes.
• Governance: It explicitly integrates human oversight, ensuring that changes to procedural knowledge are approved and traceable, preventing fully automated drift.
• Effectiveness: The proof-of-concept provides initial evidence that structured, atom-based memory improves policy-compliant behavior compared to both parametric knowledge and standard document retrieval.

The authors remain modest, acknowledging that the proof-of-concept is limited to a single synthetic process and PDF-based sources. They state that generalization to complex, real-world enterprise environments with conflicting legacy systems and numerous overlapping policies has not yet been demonstrated and is a target for future work.