Modern products such as automobiles, aircraft, and industrial equipment rely heavily on embedded software. This software (that may be running on electronic control units, sensors, and microcontrollers) must integrate tightly with the physical system architecture defined by systems engineers. Traditionally, however, systems engineering and software development have operated in separate domains. Systems engineers use tools like Model-Based Systems Engineering (MBSE) and languages such as SysML. Meanwhile, software developers rely on Agile, DevOps pipelines, and code repositories.
This separation creates friction. Requirements can be misinterpreted, traceability becomes difficult, and engineering teams struggle to keep architecture models synchronized with the actual implementation. Fortunately, a new approach is emerging that bridges this gap: treating engineering models as code and integrating them directly into modern DevOps platforms. With innovations like SysML v2 and AI-assisted development through GitLab Duo, organizations can unify MBSE and software development workflows. For organizations building complex products, this shift represents a major step toward a true digital thread connecting system design, implementation, validation, and compliance. Let’s explore this new approach further.
Benefits of Unifying MBSE and Software Development
1. A Single Source of Truth for System Architecture
Model-Based Systems Engineering enables teams to represent complex system architectures using formal models. With the introduction of SysML v2, the next-generation systems modeling language, these models can be stored as human-readable code files. This means system definitions, architecture diagrams, behaviors, and constraints can exist in the same version-controlled environment as the software itself.
When MBSE models are integrated into the development pipeline, the system architecture becomes a single source of truth that developers, systems engineers, and testers all reference. This eliminates many common issues, such as requirements drifting between models and implementation or a lack of traceability between architecture and code. It even helps with verifying that the software actually implements the system intent.
2. Improved Traceability Across Hardware and Software
Embedded systems are highly regulated in industries such as aerospace, automotive, and defense. These engineers must prove that system requirements map directly to implementation and testing.
By integrating MBSE artifacts into the development workflow, teams can trace:
- System requirements
- Functional architecture
- Software components
- Validation and testing results
This level of traceability is essential for compliance with modern standards and regulations affecting embedded products.
3. Faster Development Through Model-Driven Automation
When architecture models are expressed as structured code, AI systems can understand them much more effectively than traditional diagram-only models. This opens the door to model-driven code generation, where software is partially or fully generated from system models. Instead of manually translating requirements into implementation, developers can focus on refining and validating AI-generated solutions. The result is faster iteration cycles and reduced risk of misinterpreting system behavior.
4. Better Collaboration Between Systems and Software Teams
Systems engineers and software developers historically operate in different tools and processes. MBSE integration allows both groups to collaborate in a shared environment.
Systems engineers define the architecture and behavior in SysML models. Developers implement and refine that architecture within the same platform using DevOps workflows. AI assistants can interpret the models and translate them into working code. This creates a continuous engineering workflow from system design to deployment.
How GitLab Duo Enables MBSE Integration with SysML v2
GitLab is one of the top companies that is implementing this new approach. By expanding its role beyond traditional DevOps, it is enabling new workflows that connect engineering models directly to software implementation. Through the GitLab Duo Agent Platform, AI agents can interpret system models written in SysML v2 and generate embedded software that aligns with those designs.
SysML v2 introduces a powerful concept: Engineering as Code. Instead of storing models only in proprietary tools, SysML v2 allows engineers to store architecture definitions as structured text files that both humans and AI can understand. GitLab Duo can analyze these files and generate code that implements the defined system behavior.
From SysML Model to Embedded Software
In a demonstration project, GitLab Duo interpreted a SysML v2 model describing a simple system: a flashlight. The following demonstration shows how GitLab Duo interprets a SysML v2 engineering model and generates embedded software that runs on a microcontroller.
In the video, the system model defines how a flashlight should behave. GitLab Duo reads the model, generates the necessary embedded C code, and deploys it through a CI/CD pipeline to a Raspberry Pi Pico W device. The resulting firmware runs exactly according to the behavior defined in the system architecture. This demonstration highlights the potential of combining MBSE, AI-assisted development, and DevOps automation.
AI With Full Engineering Context
One reason this approach works well is that GitLab Duo has access to the entire project context. It can analyze:
- The SysML system model
- Existing source code
- Build configuration files
- CI/CD pipeline definitions
- Hardware interfaces
This allows the AI to generate code that fits naturally into the existing embedded project rather than producing isolated snippets. Developers still review and validate the output before committing it, ensuring that AI acts as a collaborator rather than replacing engineering expertise.
Security and Quality Built Into the Workflow
Embedded software must meet strict reliability and security standards. GitLab’s integrated DevSecOps platform ensures that AI-generated code still passes through the same quality controls as human-written code.
This includes:
- Static analysis scanning
- Security vulnerability detection
- Compliance checks
- CI/CD validation pipelines
For example, integrations with advanced analysis tools such as CodeSonar enable deep inspection of embedded code quality and security risks. Findings appear directly in GitLab merge requests and security dashboards, making them part of the normal development workflow. This approach ensures that both human-written and AI-generated code meet the same standards for safety and reliability.
Integrating MBSE and Software Development with GitLab Duo
The future of embedded engineering lies in breaking down the traditional boundaries between systems engineering and software development. With the emergence of SysML v2, Engineering as Code, and AI-powered development platforms, organizations can unify these disciplines into a single, collaborative workflow. GitLab Duo demonstrates what this future looks like. It enables teams to move from architecture to implementation faster while maintaining traceability, security, and compliance. For industries building increasingly complex software-driven products, this unified approach offers significant advantages. If you are ready to reduce translation errors between system models and code, accelerate development cycles, and strengthen collaboration between systems engineers and software developers, reach out to our experts to learn more.
