Chapter 14: Capture and Inheritance of Tacit Knowledge

1 Why Tacit Knowledge is AOSE’s Biggest Challenge

Tacit knowledge is the most hidden and destructive challenge facing Agent-Oriented Software Engineering. It is usually “embodied and contextual,” existing in experts’ intuition, informal conversations, and decades of legacy system logic, and difficult to directly extract through traditional documentation or code review.

In the era where AI Agents become execution subjects, lack of tacit knowledge leads to disastrous consequences. Imagine: a senior engineer leaves, and the knowledge in their mind about “why this field is named this way,” “this interface must delay 500 milliseconds in specific cases to avoid race conditions” disappears with them. When Agents face related requirements, they generate code based on general best practices, unaware of these hidden constraints—resulting in system crashes in production environments.

Three Core Challenges

Context-Capability Paradox: Agents need comprehensive background instructions (skills) to handle complex tasks, but these instructions quickly fill large model context windows, instead reducing the model’s ability to logically reason about current tasks.

Semantic Break Between “Requirements” and “Implementation”: Large models are usually trained on general, structured datasets, but enterprise internal tacit knowledge (like “peculiar patches written to avoid a specific hardware bug 15 years ago”) is not in the model’s weights. If this context is missing, generated “temporary logic” may cause systemic crashes.

Corporate Amnesia: In traditional software engineering, knowledge is dispersed and stored as a byproduct of the development process. In AOSE mode, if over-reliance on “just-in-time compilation” occurs without systematically capturing “why do it this way” decision paths, once projects end or teams change, the enterprise’s core logic will completely disappear.

2 Five Strategies for Tacit Knowledge Externalization

Social Interaction Agents (SIAs) Execute SECI Cycle

Teams should not pin hopes on static documents, but should deploy dedicated Social Interaction Agents (SIA) to act as coordinators for knowledge transfer. These agents utilize Nonaka’s SECI model (Socialization, Externalization, Combination, Internalization), guiding employees to transform internal intuition and experience into explicit instructions through natural language dialogue.

Specific practice:

Agents can simulate expert roles, proactively initiating “inquiries” during development:

“For this specific compliance logic, have we encountered boundary cases in the past?”

“This field naming doesn’t seem to conform to team standards, is there special historical reason?”

“I noticed the caller of this API has a special timeout handling habit, is this a convention that must be maintained?”

Through this empathetic, multi-round dialogue, unstructured tacit knowledge is captured and transformed into structured metadata.

Typical SIA workflow:

Observe developer behavior/code → Identify potential tacit knowledge → Proactively initiate inquiry →
Capture explanations → Refine into structured constraints → Store in enterprise knowledge graph

Building “Code Digital Twins” and Enterprise Memory Layer

AOSE needs a “shadow system” beyond source code. The Code Digital Twin framework not only maintains physical code but also records software’s semantic levels, including historical decisions, design trade-offs, and special handling due to legacy constraints.

Enterprise Memory Layer:

This is a persistent organizational intelligence layer connecting business requirements, security controls, and execution paths. Every agent generation action must extract context based on this layer, while simultaneously re-encoding post-generation feedback (like: why did this generated code pass verification when the previous one didn’t) back into the memory layer.

enterprise_memory:
  architecture_decisions:
    - id: AD-001
      topic: Order service splitting
      decision: Split from monolithic application to independent microservices
      rationale: Support independent scaling
      constraints: ["Must maintain compatibility with old API", "Database not directly accessible"]
      context: "2023 Double 11 traffic surge caused monolithic service crash"
      date: "2023-06-15"
      status: active

  implicit_rules:
    - id: IR-001
      description: "Username field length limit is 20 characters"
      reason: "Compatible with legacy ERP system import limitations"
      source: "2022 financial system integration project"
      criticality: high
      discovered_by: "SIA-dialog capture"

  agent_learning:
    - task_id: T-2024-001
      success_pattern: "Use Redis cache for user levels"
      failure_pattern: "Direct query to analytics database"
      lesson: "Analytics database queries exceed 200ms, must use cache"

Semantic Data Layer (SDL) as Anchor for Tacit Knowledge

By building Semantic Data Layer (SDL), abstract obscure physical table structures and hidden business calculation formulas into standard business semantics.

semantic_data_layer:
  entities:
    - name: Order
      physical_table: "t_order_2020"
      business_definition: "Complete record of customer orders, including main orders and sub-orders"
      implicit_rules:
        - "Order number format: YYYYMMDD + 6-digit sequence + 2-digit check code"
        - "Historical order queries must include time range, otherwise query optimizer fails"

  metrics:
    - name: Net Profit
      business_definition: "Net income after deducting all costs"
      formula: "(Operating income - Operating costs - Operating expenses + Special adjustment items)"
      adjustment_rules:
        - "Include subsidiary dividend adjustments (see Finance Department email 2023-06)"
        - "Exclude one-time asset disposal gains"
      validation: "Must have difference <0.1% from Kingdee system monthly reports"
      # Even if code logic is temporary, these "business truths" defined in SDL
      # that have been validated by human experts are eternal anchors

  integrations:
    - system: "ERP"
      constraint: "Order status synchronization has 5-minute delay"
      workaround: "Query prioritizes local status, asynchronous calibration"

“Agent Ethnography” Automation

Utilize long-context multimodal models to observe development and business processes, rather than just reading code.

Specific practice:

Agents can be authorized to “observe” developers’ Slack discussions, meeting records, and even operation videos. By analyzing these long-cycle multimodal sequences, agents can identify “unspoken” conventions, exception handling patterns, and team-specific “invisible rules,” achieving automation upgrade from “observation” to “knowledge modeling.”

Observation scope:

• Slack/DingTalk conversations: Capture technical discussions’ conventions and compromises
• Meeting records: Extract decision backgrounds and trade-offs
• Code review comments: Identify recurring problem patterns
• Operations operation videos: Learn non-standard failure handling processes

# Agent ethnography observation output example
ethnography_insights:
  source: "Slack-#backend-channel-2024-03"
  pattern_detected: "Order refunds must first call risk control service"
  context: "Although not mentioned in business documents, team formed this convention after 3 failures"
  confidence: 0.92
  recommendation: "Add 'risk control check before refund' as architecture constraint rule"

Deterministic Hooks and Human-in-the-Loop (HITL)

For parts where tacit knowledge is extremely complex and cannot be automated, AOSE must set Deterministic Hooks. When agent parsing requirement confidence falls below threshold, “human expert-in-the-loop” must be triggered for requirement calibration by architects who master tacit knowledge.

class IntentResolver:
    """Requirement resolver with deterministic hooks"""

    def resolve(self, intent):
        confidence = self.assess_confidence(intent)

        if confidence < DETERMINISTIC_HOOK_THRESHOLD:
            # Trigger human expert-in-the-loop
            logger.warning(f"Requirement confidence {confidence} below threshold, requesting human verification")
            return request_human_verification(intent)

        return self.auto_resolve(intent)

    def assess_confidence(self, intent):
        """Assess requirement parsing confidence"""
        factors = [
            self.check_explicit_rules_coverage(intent),
            self.check_historical_similarity(intent),
            self.check_constraint_compatibility(intent),
            self.check_semantic_layer_alignment(intent)
        ]
        return weighted_average(factors)

Typical scenarios triggering human review:

• Requirements involving legacy system integration
• Modifying core financial calculation logic
• Change impact scope cannot be automatically determined
• Modules with multiple historical failures

3 Establishing “Knowledge as Product” Culture

Development teams should shift from “code-centric” to “context engineering.” This transformation requires teams to realize that the most valuable work unit is no longer writing code, but defining, strengthening, and validating requirement context.

Three Dimensions of Cultural Transformation

From “how many lines of code I wrote” to “how many constraints I captured”:

Traditional KPIs focus on code output volume, AOSE-era KPIs should focus on knowledge asset accumulation. An engineer capturing and externalizing 10 tacit knowledge constraints in a day may be more valuable than another engineer writing 1000 lines of code.

From “individual heroism” to “collective knowledge sharing”:

In the past, senior engineers’ value lay in their ability to quickly solve problems others couldn’t. Now, this capability needs to be externalized and documented, letting Agents also “learn.” True heroes are those willing to spend time transforming intuition into reusable constraints.

From “tacit is good” to “explicit is mandatory”:

Traditional观念认为 “masters know in their hearts,” but in AOSE, this causes Agents to malfunction. Teams must establish consensus that “unclear constraints are missing constraints.”

Incentive Mechanisms for Knowledge Capture

Knowledge Review Process

Developer captures tacit knowledge → Submit to knowledge review queue →
Senior engineer reviews → Integrate into enterprise memory layer →
Agent automatically applies → Effect feedback → Knowledge iteration optimization

4 Implementation Path for Tacit Knowledge Management

Startup Phase (Months 1-2)

Goal: Establish basic framework, identify most critical tacit knowledge

Actions:

1. Deploy SIA, begin proactive inquiry for common development scenarios
2. Establish initial structure of enterprise memory layer
3. Identify 3-5 most critical domains (like orders, payments, membership) to start pilot
4. Interview senior engineers, capture “things you’d never write in documents but newcomers must know”

Outputs:

• First batch of 50 externalized constraints
• Enterprise memory layer infrastructure
• Knowledge capture SOP

Expansion Phase (Months 3-6)

Goal: Expand coverage scope, establish self-operating mechanisms

Actions:

1. Integrate SIA into development process (automatic checks before code submission)
2. Introduce agent ethnography, automatically observe team communication
3. Establish deterministic hooks, enforce human review for low-confidence scenarios
4. Regular knowledge review meetings (bi-weekly)

Outputs:

• Constraint network covering core business
• Automated tacit knowledge capture pipeline
• Knowledge contribution dashboard

Maturity Phase (Months 6-12)

Goal: Knowledge management becomes organizational instinct

Actions:

1. Knowledge capture incorporated into new employee onboarding training
2. Constraint network automatic optimization (based on Agent execution feedback)
3. Cross-team knowledge sharing and reuse
4. Measure knowledge management ROI (improved Agent success rate, reduced failures)

Outputs:

• Self-evolving enterprise knowledge graph
• Knowledge management becomes team DNA
• Quantifiable business value

5 Common Pitfalls and Avoidance

Over-Capture

Pitfall: Attempting to capture all knowledge, causing excessive team burden and resistance.

Avoidance:

• Focus on “high-impact, high-risk” domain tacit knowledge
• Prioritize capturing knowledge points that caused production failures
• Use Pareto principle: 20% of key constraints solve 80% of Agent errors

Capture-and-Forget

Pitfall: Thinking it’s done once knowledge is written into documents, not updating, verifying, or applying.

Avoidance:

• Constraints must integrate with Agent execution systems
• Regularly review constraint validity (quarterly)
• Establish “last verification time” markers for constraints

Knowledge Silos

Pitfall: Knowledge captured by each team not shared, causing repetitive work and inconsistent standards.

Avoidance:

• Establish unified enterprise memory layer infrastructure
• Cross-team knowledge review and reuse mechanisms
• Shared constraint libraries and best practices

Ignoring Human Factors

Pitfall: Over-reliance on automated capture, neglecting people’s willingness to actively share.

Avoidance:

• Establish psychologically safe environment, making knowledge sharing a rewarded behavior
• Protect knowledge contributors’ time, don’t make them “living documents”
• Acknowledge and respect experts’ value, rather than trying to completely replace them

6 Chapter Summary

Tacit knowledge is AOSE’s biggest invisible risk and biggest opportunity. Through systematically capturing and externalizing tacit knowledge, teams can:

Reduce risk:

• Agents operate in “enterprise reality,” not “semantic vacuum”
• Key business logic doesn’t disappear with personnel turnover
• Reduce fear of “don’t know why it’s this way, but definitely don’t change it”

Improve efficiency:

• Probability of Agents getting it right the first time greatly improves
• Newcomer onboarding time shortens (Agents and knowledge graphs become mentors)
• Reduce repeated pitfalls and repeated inquiries

Build assets:

• Enterprise knowledge graph becomes true core competitiveness
• Every project leaves reusable constraints and patterns
• From “relying on individual heroes” to “relying on collective wisdom”

In Agent-Oriented Software Engineering, tacit knowledge externalization is no longer an option, but a prerequisite for success. Only when Agents can understand and respect enterprises’ unique history, constraints, and conventions can AOSE truly deliver value. This is not an overnight process, but every investment will bring exponential long-term returns.