Skip to main content
This page is displayed using automated translation. View in US English instead?
Company Core Technologies

Software Architecture and Design

The Software Architecture and Design research field defines the architectural paradigms for self-evolving industrial software. We transform static blueprints into living software architectures that let systems proactively reinvent themselves while ensuring correctness across complex landscapes.

What if industrial software was no longer a static tool, but a living architecture that is self-evolving to stay correct?

Our research is reshaping the future of Siemens’ digital portfolio by developing software architectures that are built to evolve. We transform fixed blueprints into dynamically adapting architectural artefacts that proactively manage complexity. By integrating operable autonomy and self-awareness into the core architecture, we ensure that our software remain resilient and correct, even as their environments and requirements continuously shift.

What matters is the evolution of software architecture from a fixed blueprint to a dynamically adapting artefact that preserves correctness throughout its own evolution.

Split image showing abstract neon glass blocks and a developer working on multiple monitors
Two colleagues collaborating in a modern office, looking at a laptop screen

Software Architecture and Design research focuses on the transition from static blueprints to living software architectures. We define the principles for self-evolving software architectures and the architectural quality characteristics required for operable autonomy. Our work drives strategic architecture evolution and portfolio modernization, enabling the shift toward AI-native software paradigms.

Key research areas center on self-awareness for software systems, frameworks for self-evolution, federated software architecture design, autonomous governance and AI-augmented data integration. A central pillar of our domain is the engineering of correctness envelopes and verification harnesses. By embedding self-awareness and traceability into the architectural core, we ensure that complex industrial systems and agentic architectures remain resilient, trustworthy and correct throughout their own evolution.

This Company Core Technology focuses on the engineering of self-evolving and federated industrial software applications through advanced software architecture frameworks. We drive strategic architecture evolution, ensuring that our software remains correct and trustworthy in high-stakes environments. By applying correctness envelopes and architectural characteristics for operable autonomy, we enable industrial applications to proactively adapt while maintaining operational integrity.

Beyond foundational research into living architectural principles, this Company Core Technology offers expert consulting, architecture reviews and technical evaluations. As a horizontal field, it delivers the architectural patterns and future-proof guidance needed to build resilient, industrial-grade software across all Siemens business domains.

Icon for Software Architecture and Design
Publications

Explore our featured papers


The few-shot dilemma: Over-prompting large language models

Published in: 2025 3rd International Conference on Foundation and Large Language Models (FLLM)
Yongjian Tang; Doruk Tuncel; Christian Koerner; Thomas Runkler

Over-prompting occurs when excessive examples in prompts degrade LLM performance, challenging traditional few-shot learning assumptions. To study this dilemma, a prompting framework evaluated random sampling, semantic embedding and TF-IDF vector selection across models like GPT-4o, DeepSeek-V3, and LLaMA-3.1. Results show that too many domain-specific examples paradoxically harm accuracy. Tested on software requirement datasets, gradually increasing stratified and TF-IDF-selected examples revealed optimal prompt sizes. This approach avoids over-prompting while outperforming state-of-the-art requirement classification by 1%.
View at publisher's page


LLM-based agentic systems for software engineering: Challenges and opportunities

Submitted to: SE2026, Gesellschaft für Informatik, Bonn
Yongjian Tang, Thomas Runkler

Despite LLM advancements, complex software engineering tasks demand collaborative, specialized approaches. This paper systematically reviews the emerging paradigm of LLM-based multi-agent systems across the entire software development lifecycle, including requirements engineering, code generation, testing and debugging. It examines model selection, evaluation benchmarks, agentic frameworks and communication protocols. Additionally, the work highlights key challenges like orchestration, human-agent coordination, cost optimization and data collection, offering essential insights into the state of agentic software engineering.
View at publisher's page


Model-driven legacy system modernization at scale

Published in: ReCode '26: Proceedings of the 1st Workshop on Code Translation, Transformation, and Modernization, pages 13 ‑ 18
Tobias Böhm, Jens Guan Su Tien, Mohini Nonnenmann, Tom Schoonbaert, Bart Carpels, Andreas Biesdorf

This experience report presents a four-stage model-driven approach (analysis, enrichment, synthesis, transition) that inserts a technology-agnostic intermediate model between legacy codebases and modern target platforms. Applied to a large industrial .NET application, it semi-automatically migrates user interfaces and page structures to modern web stacks while preserving functional behavior. By consolidating architectural knowledge into explicit models, it improves maintainability and developer experience. Despite layout challenges requiring manual effort, the approach reduces risk, scales effectively and offers reusable patterns.
View at publisher's page


Bridging formal syntax and LLM semantics: Extracting knowledge graphs for legacy code understanding

Published in: 2026 IEEE 23rd International Conference on Software Architecture Companion (ICSA‑C)
Henrik Thillmann; Bernhard Rumpe; Andreas Biesdorf

Established enterprises often rely on legacy systems that are difficult to maintain due to outdated languages and unclear identifiers. However, replacing these systems poses the risk of losing their proven reliability. Large language models can assist with architecture recovery and modernization, but they require precise context management. Since code is a parseable formal language, retrieval can exploit program structure instead of relying on unstructured text. We propose a parsing-based methodology to build a structure-aware knowledge graph for GraphRAG. This approach demonstrates improved retrieval precision and multi-hop architectural reasoning in an industrial case study.
View at publisher's page