How Siemens "slices the elephant," advancing agentic workflows for industrial software development
Siemens partnered with Google Cloud to develop Knowledge Fabric, an AI-powered agentic system that modernizes legacy industrial software by using knowledge graphs and intelligent agents to navigate massive, fragmented codebases. The solution enables autonomous agents to reason across decades of accumulated code, documentation, and requirements, freeing engineers from repetitive work to focus on innovation while maintaining strict industrial compliance standards.
Key Takeaways
- Knowledge Fabric uses knowledge graphs on Spanner Graph and agentic AI to handle industrial software codebases with hundreds of millions of lines of code that standard AI tools cannot effectively process.
- The system integrates code structure, scattered documentation (Jira, Confluence, PDFs), and functional requirements into a unified, queryable knowledge representation that preserves relationships between assets.
- Siemens faced a four-part challenge: massive scale exceeding LLM context windows, fragmented knowledge across multiple sources, complex historical traceability requirements, and strict compliance needs over 15-20 year system lifespans.
- Knowledge Fabric reduced implementation effort in a pilot migration to web-based interfaces by enabling agents to autonomously reason across the codebase rather than relying on developers for manual navigation.
- Standard RAG and vector databases proved insufficient because they flatten code structure, losing critical relationships between classes, files, modules, and requirements that industrial systems require.
Stats & Key Facts
- #Siemens' codebases span hundreds of millions of lines of code developed over more than a decade
- #Industrial systems often require 15 to 20 years of operation with strict quality and compliance standards

The Industrial Software Challenge
For Siemens, modernizing legacy industrial software presented obstacles that transcended typical software development problems.
- ›Codebases contain hundreds of millions of lines spanning over a decade, far exceeding standard LLM context windows
- ›Critical knowledge scattered across disconnected systems: source code, Jira tickets, Confluence pages, and scanned PDF manuals from the early 2000s
- ›Tracing relationships between specific code lines and decade-old functional requirements was impossible through manual or conventional tooling
- ›Systems must maintain strict quality, compliance, and lifecycle standards over 15-20 years of operation, making AI-generated changes non-negotiable in accuracy and traceability
Modernizing large-scale industrial software has been compared to rebuilding a jet while flying it. Siemens faced this reality with software that powers factories, energy grids, and transportation networks worldwide. The company's domain expertise spanning factory automation, process automation, energy infrastructure, and intelligent transportation could not be replicated by off-the-shelf AI solutions, yet legacy code presented an immovable barrier.
The core problem was that hallucinated or unvalidated AI-generated changes are operationally unacceptable in industrial contexts. Unlike consumer software, failures can affect critical infrastructure and public safety. This demanded a fundamentally different approach than existing coding assistants offered.
Why Standard AI Tools Fall Short
Conventional approaches to code understanding proved inadequate for Siemens' needs.
- ›Standard retrieval-augmented generation (RAG) treats code as flattened text, losing the inherent structural relationships critical to understanding a codebase
- ›Vector databases cannot represent that a class belongs to a file, which belongs to a module, which serves a specific functional requirement
- ›Context window limitations of standard large language models cannot accommodate repositories of hundreds of millions of lines
- ›Fragmentation of knowledge across unstructured sources (PDFs, tickets, documentation) prevents comprehensive understanding of system dependencies and historical decisions
According to Agata Gołębiowska, technical lead at Google Cloud, the fundamental issue was that code isn't merely text. It has inherent structure and relationships that must be preserved. When flat vector databases flatten code into embeddings, they destroy the semantic and structural information essential for reasoning about industrial systems.
Standard coding assistants lacked the contextual depth required to navigate complex, multi-layered industrial codebases. The gap between what these tools could do and what Siemens needed became the catalyst for developing a specialized solution.
Knowledge Fabric: The Agentic Solution
Siemens and Google Cloud designed Knowledge Fabric to treat the entire software ecosystem as an intelligent, interconnected knowledge system.
- ›Built on Spanner Graph to model the inherent structure of codebases with semantic relationships preserved at every level
- ›Incorporates Gemini API, Google Agent Development Kit, Claude Code, and Anthropic tools to enable autonomous reasoning across the knowledge graph
- ›Uses Graph Query Language (GQL) to allow agents to traverse and query structural relationships between code elements and requirements
- ›Generates embeddings for every node in the graph to enable semantic understanding beyond structural queries
The Knowledge Fabric agent goes beyond keyword matching to understand relationships between assets across the entire software ecosystem. Rather than treating code, documentation, requirements, and historical records as separate silos, it maps connections between domains. This allows agents to link specific code snippets directly to requirements in design documents, trace changes back through Jira histories, and connect current implementation to legacy decision-making.
By ingesting the entire software ecosystem into an intelligent agentic system equipped with custom knowledge graphs, the solution enables autonomous agents to reason across decades of accumulated knowledge. Franz Menzl, senior vice president of product creation excellence at Siemens, described the approach: 'We aren't just helping developers optimize their development time; we are enabling autonomous agents to reason across the past to build the future.' The goal is freeing engineers from repetitive work so they can focus on higher-value problem solving and customer-facing innovation.
Pilot Results and Impact
Early deployment of Knowledge Fabric demonstrated measurable benefits for software modernization efforts.
- ›Pilot migration of existing systems to web-based interfaces showed reduced implementation effort
- ›Engineers freed from navigating complex legacy code to focus on customer innovations and strategic development
- ›System maintained full compatibility with existing infrastructure while modernizing interfaces and functionality
- ›Autonomous agents successfully reasoned across fragmented knowledge sources to identify optimization opportunities
The pilot program migrating existing frontiers to web-based interfaces provided proof that the Knowledge Fabric approach could deliver practical value. By automating the most time-consuming aspects of code understanding and navigation, the system allowed skilled engineers to redirect their expertise toward higher-leverage work. This shift from maintenance and investigation to innovation represents the fundamental value proposition of agentic AI in industrial contexts.
Architectural Components and Technology Stack
Knowledge Fabric's effectiveness derives from its sophisticated integration of multiple Google Cloud and AI technologies.
- ›Spanner Graph provides the distributed database foundation capable of handling massive knowledge graphs with strict consistency requirements
- ›Google Agent Development Kit enables the creation of autonomous agents capable of reasoning and tool use
- ›Gemini API provides the foundational language model capabilities with extended context understanding
- ›Anthropic Claude Code integration allows specialized code understanding and generation
- ›Custom knowledge graphs model both code structure and semantic relationships between all system artifacts
The architecture deliberately separates structural querying from semantic understanding. Agents use Graph Query Language for precise navigation of relationships, while embeddings generated for every node enable semantic search and reasoning. This dual approach ensures both accuracy and contextual understanding, which is essential for industrial systems where mistakes are costly.
The solution represents a significant departure from earlier AI-assisted development approaches. Instead of asking what traditional tools could do and then trying to fit the problem to the tool, Siemens and Google Cloud engineered the infrastructure to match the requirements of the problem. The result is an agentic system designed from the ground up for industrial-scale, mission-critical software modernization.
Compliance, Traceability, and Trust
Industrial software demands an accountability standard that Knowledge Fabric was engineered to meet.
- ›All AI-generated outputs must be explainable, traceable, and verifiable due to strict industrial compliance requirements
- ›Hallucinated or unvalidated changes are operationally unacceptable in systems managing critical infrastructure
- ›Knowledge graphs enable full audit trails connecting code changes back through requirements and historical context
- ›Graph structure preserves the reasoning path agents follow, allowing engineers to validate agent decisions before deployment
The emphasis on traceability and explainability distinguishes Knowledge Fabric from consumer-oriented AI development tools. Every recommendation an agent makes can be traced back through the knowledge graph to source documents, previous implementations, and requirements. This transparency is not merely a feature but an operational necessity when software controls power grids, factory automation, and transportation systems.
The Future of Agentic Industrial Development
Knowledge Fabric demonstrates how agentic AI can tackle domain-specific challenges that general-purpose tools cannot address.
- ›The 'slicing the elephant' approach breaks massive problems into navigable, agent-solvable components through knowledge graphs
- ›Domain-specific AI solutions require deep understanding of both the technology and the industry problem space
- ›Agentic workflows with proper knowledge representation can reason autonomously while maintaining industrial-grade reliability standards
- ›The solution model proves applicable to other industries with legacy systems and fragmented knowledge across decades of operation
Siemens' approach with Knowledge Fabric suggests a broader pattern for how enterprise AI can evolve. Rather than applying generic large language models to complex industrial problems, effective solutions require specialized knowledge representation, domain-aware agents, and strict frameworks for verification and traceability. This represents a maturation of AI in enterprise software development, moving from narrow automation tasks to comprehensive reasoning across entire software ecosystems.
Frequently Asked Questions
Why couldn't standard AI coding assistants solve Siemens' problem?
Standard coding assistants and RAG systems treat code as flat text, losing critical structural relationships like class-to-module hierarchies. Siemens' codebases contain hundreds of millions of lines of fragmented knowledge across multiple sources, far exceeding LLM context windows. These tools also cannot guarantee the explainability and traceability required for industrial systems operating over 15-20 years.
What is Spanner Graph and why is it central to Knowledge Fabric?
Spanner Graph is a distributed database technology that enables Knowledge Fabric to model the inherent structure of massive codebases while preserving relationships between code elements, documentation, and requirements. It allows agents to query structural connections via Graph Query Language and generate embeddings for semantic understanding, solving the limitation of flat vector databases.
How does Knowledge Fabric maintain compliance and reliability for critical infrastructure?
The system ensures all AI-generated outputs are explainable, traceable, and verifiable by maintaining full audit trails through the knowledge graph. Every agent recommendation can be traced back to source documents and historical context, and engineers can validate agent decisions before deployment. This approach makes hallucinated or unvalidated changes detectable before reaching production systems.
What measurable benefits did the pilot program show?
The pilot migration to web-based interfaces demonstrated reduced implementation effort and freed engineers from navigating complex legacy code to focus on customer innovations. The system maintained full compatibility with existing infrastructure while modernizing functionality, proving the approach's practical value.
Is Knowledge Fabric applicable to other industries beyond industrial software?
Yes, the solution model is applicable to any industry with legacy systems spanning decades, fragmented knowledge across multiple sources, and high requirements for compliance and traceability. The approach of using domain-aware knowledge graphs with autonomous agents represents a generalizable pattern for enterprise software modernization.
Knowledge Fabric demonstrates that solving enterprise AI challenges requires specialized architectures tailored to domain complexity rather than applying general-purpose tools.
Continue Learning
Comments
Sign in to join the conversation