Model-Based Systems Integration

As more teams bring in models like OpenAI, Claude, or Gemini and connect them to CRMs, analytics tools, or internal apps, things start to break. Not on the surface. But deep down, in the wiring: • Interoperability becomes a nightmare.    • Every model needs to talk to every system.    • Suddenly, you're managing M × N connections, and it's a mess.    That’s where something like the Model Context Protocol (MCP) makes a difference. With MCP: • Each model integrates once. • Each tool integrates once. • And the system just works.    You go from M × N complexity to M + N clarity. It’s not just a cleaner setup—it’s what makes AI systems scale without collapsing under their own weight. I’ve broken this down visually below for anyone trying to make sense of the value of MCP, whether you're writing the code or managing the roadmap. Do you think protocol-first design is where AI infrastructure is headed?

Venture capital and media attention fixate on foundation model capabilities, but the competitive battleground in AI has shifted to the unsexy, boring parts of AI - things like orchestration layers, retrieval systems and connective infrastructure. Organisations do not deploy “a model”. They deploy workflows integrating models with proprietary data, existing software systems, human review processes, compliance controls and operational monitoring. The sophistication of this second-order infrastructure increasingly determines who wins in AI deployment. The Model Context Protocol exemplifies this shift. By providing a standardised interface for AI systems to connect with external tools and data sources, MCP solves the “M times N” problem that plagued earlier integration efforts. Connecting M models to N tools previously required M times N custom integrations, each demanding bespoke engineering, testing and maintenance. MCP reduces this to M plus N by providing a common protocol. The seemingly technical detail of interoperability standards enables the ecosystem effects that allow agentic AI to scale across organisations and use cases. Retrieval-Augmented Generation represents another critical infrastructure layer. Generic models know only what appears in their training data. Enterprise value requires grounding AI responses in current, proprietary organisational information. RAG systems retrieve relevant context from document stores, databases and knowledge graphs, then inject that context into the model’s reasoning process. The engineering required to make this work reliably encompasses vector databases, embedding models, semantic search, ranking systems, access controls and cache management. These components are invisible to end users but determine whether an AI system produces valuable insights or expensive nonsense. The orchestration market has grown explosively as organisations recognise that managing multiple specialised models and tools requires sophisticated coordination. Rather than forcing every query through a single expensive frontier model, orchestration systems route requests intelligently. Simple queries go to fast, cheap models. Complex reasoning tasks go to sophisticated models. Specialised tasks go to fine-tuned domain models. This arbitrage across model capabilities and costs determines the unit economics of AI deployment. These systems sit between enterprise users and external AI providers, enforcing usage policies, managing costs, logging interactions for audit and blocking potentially harmful outputs. Deploying AI without a gateway has become as negligent as deploying web servers without firewalls. The governance, compliance and risk management capabilities embedded in these infrastructure layers determine whether enterprises can scale AI deployment while maintaining controle. The companies building superior connective tissue will matter more than those training marginally better models.

A Story of two Embedded Engineers. Same engineering college. Same automotive company. Same ECU project at 25. Venu chose the traditional path: • Wrote everything in C • Managed memory manually • Debugged with breakpoints and printf() • Maintained separate documents for requirements, design, and test cases • Integration was always a pray to god. Gopal adopted Model-Based Development (MBD): • Used Simulink for Systems and Unit modelling • Linked Requirements directly from the beginning to ensure traceability. • Shifted left by testing early at MIL • Generates the code using Auto-Code Generators. • Functional testing as per requirements and ensures traceability. • Integration with version control and CI/CD. At 35, Venu was a C-Code guru. His code was fast, but hard to maintain. Each change risked regression. Code reviews were long, and on-boarding juniors was slow. Gopal's models were modular, reusable and well-documented. He could validate logic before hardware is ready. His team delivers faster, with fewer bugs and better compliance with ISO 26262. Venu's Code worked. But Gopal's system scaled. Because Embedded Development isn't just about writing code. Its about designing systems, ensuring safety and accelerating concepts. Model-Based Development isn't just a tool. It's a mindset. One that builds for the future and not just for next release.

For decades, the V-Model has been a cornerstone development methodology for complex, mechatronic systems. However, increasing complexity, shorter development cycles, and growing uncertainty in supply chains have sparked an intense debate about its continued validity. Critics argue that the V-Model is too rigid, reinforcing siloed domain development, an approach that appears increasingly outdated in a world dominated by E/E and embedded software. As alternatives, CI/CD-inspired approaches from software engineering or newer I-Model–based processes are proposed, emphasizing continuous system integration and unified data models. Spoiler: In this post, I’m not advocating for one of these approaches. Instead, I want to highlight which elements should be considered. The V-Model One of the greatest strengths of the V-Model is its clarity. It breaks down highly complex development processes into manageable sub-processes, assigns responsibilities across domains, and creates a shared understanding of product development. The traditional temporal separation into system design, development, and integration is increasingly challenged by simulation-driven system integration. This is why the classic “left and right flank” is often considered outdated. That criticism is valid, but as we all know: “All models are wrong, but some are useful.” Simulation and AI will replace large portions of physical system integration, but not all of it. The right flank of the V-Model still has a reason to exist. CI/CD Some argue that CI/CD practices from software development are the right answer to manage complexity and ensure agility. And indeed, especially at the component level, tight coupling of CAD, simulation, and automated test pipelines enables rapid exploration and optimization of design variants. Designs whose quality can be quantified within seconds or minutes via fast feedback loops are prime examples of how CI/CD can dramatically accelerate product development. Integrated I-Model Early system integration becomes possible when system-wide data models (engineering data backbone) guide the entire development process. This allows partial validation (and even verification) of the system very early on. Increasingly realized through MBSE, RFLP, and coupled simulations (co-simulation), these approaches help identify incompatibilities and design flaws, when they can still be eliminated efficiently through simulation. As a result, the left flank of the V-Model is massively strengthened, design spaces can be explored much deeper, and parts of the traditional right flank effectively move to the left. 🔍 Conclusion From my perspective, the V-Model will evolve, not disappear. It will adapt and absorb elements from CI/CD and integrated I-Model approaches rather than becoming obsolete. What’s your take on this evolution? Sebastian Angerer | Vlad Larichev | Nitin Ugale | Dr. Pascalis Trentsios | Andreas Kiep #SystemsEngineering #ProductDevelopment #MBSE #DigitalEngineering

AI is shifting from model-centric to system-centric architecture. This changes how we build production AI systems. Here's what's happening and why it matters. What's changing:  → Focus moves from models to complete systems → Standard protocols replace custom integrations → Relationships matter more than keyword matching → Workflows become predictable and debuggable → Edge deployment becomes practical Key differences: Old approach: Custom integrations for each model  New approach: MCP provides one standard interface. Think of MCP like USB-C for AI. One connection works everywhere. Old approach: Keyword matching in RAG  New approach: GraphRAG understands relationships. GraphRAG maps how concepts connect. It answers "how" and "why" questions better. Old approach: Fixed workflows that break unpredictably  New approach: Flow engineering with state machines, Explicit states and transitions. Predictable execution paths you can debug. Old approach: Cloud-only large models  New approach: Right-sized SLMs for edge devices SLMs run locally. Faster responses. Better privacy. Lower costs. Why it matters: Production AI needs reliability, not just intelligence. 🔷 System-centric architecture gives you: 🔷 Predictable behaviour you can debug 🔷 Standard protocols that reduce complexity 🔷 Edge deployment for privacy and speed 🔷 Relationship-aware reasoning for better answers My take: Start thinking in systems, not just models. Use MCP for integrations. Try GraphRAG for complex questions. Design flows with state machines. Consider SLMs for simple tasks. The shift is happening now. Systems that adapt will win. Found this helpful? Follow me for more AI insights.

The integration that transforms asset integrity from reactive to predictive. Most facilities manage Corrosion Control Documents, Integrity Operating Windows, and Risk-Based Inspection as separate activities. This fragmentation creates blind spots that undermine all three efforts. True asset integrity emerges when these elements work together in a continuous feedback loop, not as isolated compliance exercises. The diagram shows how data should flow between three critical systems. Corrosion Control Documents define degradation mechanisms, corrosion rates, materials data, and mitigation measures based on process chemistry and operating conditions. These documents establish the technical foundation that guides both monitoring and inspection strategies. Integrity Operating Windows translate CCD knowledge into real-time process limits. Critical parameters like temperature, pH, and chloride levels get defined ranges with alarm thresholds. When operations drift outside these windows, the system captures deviation duration and operating condition history… data that directly affects probability of failure calculations. Risk-Based Inspection takes inputs from both CCDs and IOW monitoring to optimize inspection planning. Real-time process deviations inform risk calculations. Inspection results then validate or challenge assumptions about corrosion rates and degradation mechanisms, feeding back into CCD updates and potentially revised IOW limits. The continuous loop enables dynamic optimization. When inspection finds accelerated corrosion, the CCD gets updated with new rate data, IOW limits may tighten, and RBI models recalculate inspection priorities. When IOW excursions occur, RBI strategies adjust inspection timing based on actual exposure rather than generic schedules. Most organizations treat these as separate documents and systems maintained by different teams. The integration challenge is organizational. Breaking down silos between inspection, operations, and materials engineering requires both digital platforms and cultural change. Digital systems now enable this integration through unified data models that connect process historians, inspection databases, and integrity management platforms. The technology exists to make the feedback loop automatic rather than manual. How effectively does your facility integrate corrosion knowledge, process monitoring, and inspection planning into a unified integrity management approach? *** P.S.: Looking for more in-depth industrial insights? Follow me for more on Industry 4.0, Predictive Maintenance, and the future of Corrosion Monitoring.

From V to Data-Centric Engineering: Why We Need a New Model For decades, the V-Model shaped systems engineering. On the left side, requirements and architectures were defined. On the right side, systems were validated and verified. This structure worked well in a world where hardware was dominant and software played a secondary role. But today, this separation is breaking down. Modern products are cyber-physical systems: hardware and software are deeply connected, functions evolve after market launch, and validation cannot wait until the end of development. The strict “left versus right” logic of the V no longer reflects reality. The alternative is not just to turn the V into an O. The real step forward is to make the data itself the central object of engineering. Imagine a model where requirements, functions, logical architectures, hardware, software, and verification are not separate tracks but elements of a single integrated data point. This data point becomes the smallest unit of development. It contains the requirement itself, the functional description, the logical design, the hardware and software mappings, and the corresponding test cases. Instead of passing information from left to right, both perspectives are always visible in one place. The benefits are obvious: • Traceability is inherent, because every requirement is directly linked to design and validation. • Iterations are faster, because updates in software or hardware instantly propagate through the model. • Quality increases, because inconsistencies are detected the moment they arise. Take the example of adaptive cruise control in a car. In a traditional V, the requirement, the logic, the radar hardware, the ECU software, and the test cases would all be managed in different silos. In a data-centric approach, they are all facets of one object. If the control algorithm changes, the requirement trace, the hardware mapping, and the test cases update automatically. This shift turns engineering into a continuous, connected process. Instead of handing work from one side of the V to the other, teams work around a shared, living model. The result is not a diagram with two sides, but a network of data objects that evolve together. The V was about structure. The O was about loops. The future is about integration: one data-centric model, where every element of a system is connected through a common digital thread. #SystemsEngineering #ModelBasedEngineering #DigitalThread #Innovation #FutureEngineering

How can engineering teams maintain autonomy when they are collaborating with many other teams on a complex system? There has been a rising answer to this problem in the non-software world: Model-Based Systems Engineering. The old way is the document-based approach: many documents are generated by different teams to capture the system's design from various stakeholder views, such as software, hardware, safety, manufacturing, etc. Every time one stakeholder changes a requirement in one document, it requires every other team to synchronise and manually update their documents. This makes every change slow and makes the whole job frustrating, as teams spend most of their time dealing with other teams' changes rather than thinking about the best technical solutions. The digital-modeling approach of Model-Based Systems Engineering creates a single source of truth for the system on which every team can autonomously contribute, while technology enables seamless synchronisation. The best implementation I have seen of this is at Jimmy, where Antoine Guyot, Mathilde Grivet and Charles Azam are building micro nuclear reactors to decarbonise industrial heat. Their whole system is modeled using Python and all the changes are synchronised using Github. This allows them to make multiple changes a day and even automate the verification of engineering and regulatory requirements. The result: a big update in their design takes them days instead of the many months expected in their industry. The result is much safer, thanks to the automated checks and the lack of copy-pasting errors. And the teams can focus on the value, creating ingenious technology to reduce greenhouse gas emissions. This is the idea we tried to capture with the Tech-Enabled Network of Teams principle in The Lean Tech Manifesto: leveraging tech innovation to reduce the need for coordination between teams and increase autonomy at scale. #LeanTech #TechEnabledNetworkOfTeams

I used to think MBSE was a colossal waste of time and resources. ↳ I saw projects derailed by complex tools ↳ I witnessed teams drowning in model minutiae ↳ I heard countless stories of MBSE implementations gone wrong A year ago, I would have told you Model-Based Systems Engineering was just another overhyped trend destined to fade away. But I couldn't have been more wrong. Here's what changed my mind: 1. Lockheed Martin Space used MBSE to simulate the OSIRIS-REx spacecraft's mission, leading to successful asteroid sample retrieval. 2. A major automotive company cut vehicle development time by 30% using MBSE-driven digital twins. 3. NASA slashed their preliminary design review process from 6 weeks to 3 using MBSE workflows. These weren't just marginal improvements. They were game-changers. So why the initial struggle? → Many organizations jumped into MBSE without proper planning → Teams focused on tools rather than processes → The shift from document-centric to model-centric thinking was underestimated The key to MBSE success? A strategic, phased approach: 1. Start small: Apply MBSE to a pilot project 2. Focus on value: Identify where MBSE can have the most impact 3. Invest in training: Equip your team with the right skills 4. Choose the right tools: Prioritize usability and integration 5. Embrace cultural change: Foster a model-centric mindset MBSE isn't just transforming Systems Engineering; it's revolutionizing how we approach complex problems across industries. Yes, the journey can be challenging. But the destination? It's worth every obstacle overcome. Are you on the MBSE journey? Share your experiences – good or bad. Let's learn from each other and drive this transformation forward. #MBSE #SystemsEngineering #EngineeringInnovation #DigitalTransformation

Everyone is talking about the rise of agent frameworks, but no one wants to talk about the uncomfortable reality. The interface layer we are building today may not survive the next generation of AI. MCP-style tooling made one big assumption: The model needs a protocol because it cannot reliably understand systems, APIs, or workflows on its own. That assumption is already starting to crack. Across the industry, research teams are moving in a very different direction. Instead of relying on predefined tool schemas, they are training models to: 1. read an API reference as text 2. infer how to call that API 3. test calls inside a safe environment 4. learn the behavior of the system 5. self-correct without a formal protocol If this path succeeds, today’s integration layer becomes a temporary bridge, not the final design. Here is a simple example. Today, if an agent needs to update a support ticket, we hand it a specific tool: update_ticket(ticket_id, status, notes) The agent relies on the schema, the validation, and the guardrails. But imagine a model that can read the entire API documentation for a support system, understand how endpoints relate, generate the right call, test it, and monitor the response. No schema needed. No adapter needed. No custom MCP server needed. It interacts with your system the same way a new engineer does on their first day. Another example. Today, if an agent needs access to an internal SQL database, you build a tool with constraints. But imagine a model that can: • read the ERD • understand table relationships • check permission boundaries • optimize the query • validate the result set • propose better indexing strategies All from documentation and prior examples. At that point, tool schemas feel like training wheels. So what does this mean for teams building on today’s stack? It means we should treat the current tool layer as scaffolding. Useful. Necessary. Temporary. The real question for enterprises is not whether MCP-style integrations will be replaced. The question is how fast. And the answer depends on one thing. Whether models learn to understand structured systems with the reliability we expect from software engineers. If they do, the industry will move from: protocols to understanding from schema based to context based from manual adapters to self derived system knowledge. This would not make today’s work wasted. Scaffolding is never wasted. It helps build the first version of a structure that lasts far longer than the scaffolding itself. If you are investing in agent ecosystems today, the mindset shift is simple: Build for now. Design for replacement. Assume the tool layer will shrink, not grow. The next era of agents will not just follow instructions. They will understand systems.