The Department of Defense has made meaningful progress on digital engineering. We’ve seen tools deployed for modeling, simulation, lifecycle management, sustainment analytics, and more.
However, turning tools into a truly integrated environment – where context, traceability, and automation can operate across boundaries – remains an ongoing challenge.
At EXPANSIA, we’ve been focused on that integration layer. Not just installing tools side by side but designing the connective tissue that makes them work together in a way that’s responsive to the mission. And as we look toward what’s next, we’ve begun to explore how Anthropic’s Model Context Protocol (MCP) might help us take that integration to a new level.
The Current State: Toolchains That Coexist, Not Cooperate
In most environments what gets called an “Integrated Digital Environment (IDE)” is often a collection of digital tools deployed to a shared infrastructure. That’s a practical and important first step, but in many cases, the tools aren’t aware of each other. Data moves between them via brittle scripts, file drops, or human-in-the-loop copy-paste routines. Integration becomes a maintenance burden, and automation is constrained to predefined handoffs.
This isn’t a critique. It’s where nearly all of us start, and it’s a familiar pattern: co-location first, followed by customized interfaces as needed. It works, but it doesn’t scale easily. And it’s hard to layer in intelligent behavior when each tool speaks its own language.
That’s why we’ve invested significant time into thinking carefully about what it means for an IDE to be truly integrated.
Why MCP Caught Our Attention
Anthropic’s Model Context Protocol (MCP) offers a fresh take on the integration problem. Instead of wiring tools together in bespoke ways, it proposes a common interface protocol – a way for tools to expose their structure, context, and state in a format that agents (or other tools) can understand and act on.
The protocol defines a common schema for tools using concepts like Tool, View, Node, and Command. These allow agents to reason about interfaces semantically and act responsibly. This isn’t just about getting tools to talk, it’s about getting them to cooperate securely, observably, and with shared intent.
To be clear, MCP is an enabler – not a plug-and-play solution – and orchestration logic, policy enforcement, and agent behavior must still be implemented on top. We’re
still evaluating how well MCP can serve defense-specific use cases, but what stands out is its potential to simplify how we orchestrate tools and introduce AI-enabled automation without sacrificing traceability or operational oversight.
From Scripted Workflows to Contextual Agents
We’ve previously shared the power of our digital detective, SEEKR, and how that platform has been leveraging machine learning to identify readiness-critical parts. These are parts that could be produced through alternative methods such as additive manufacturing.
With a more robust integration layer, an agent could follow that thread: identifying the flagged part, tracing it to the relevant models, assessing validation gaps, and prompting the right team or simulation run. However, without consistent access, metadata, or tooling semantics, those opportunities remain out of reach.
Protocols like MCP appear to open that door. They give us a way to express not just data, but meaning – what a model represents, where it sits in a lifecycle, whether it’s been reviewed, and under what mission scenario it applies.
That’s the kind of context agents need to act responsibly, and it’s what is often missing in today’s toolchains.
The Layer We're Exploring: Digital Rules of Engagement (ROE)
As we consider what the architecture for agent-enabled IDEs could look like, another needed layer has emerged. While MCP defines how agents interact with tools, it’s apparent that those agents require guardrails or context that governs what agents are allowed to do, where they’re allowed to operate, and under what circumstances. In the defense space, we would refer to this as rules of engagement (ROE), and this metaphor seems to hold in the digital realm.
For example:
- Can an agent annotate a model? Or just read metadata?
- Is it authorized to request a simulation run? Or must it notify an engineer?
- Should certain actions be logged or gated based on model criticality?
These kinds of questions aren’t meant to restrict automation unnecessarily, but to make sure it’s accountable and aligned to mission outcomes.
Where We Are Now
We’re still early in our journey with MCP (it was just formally released last Fall after all). We haven’t fully adopted the spec, and we’re working through what it looks like to layer it into real-world environments. But what we’ve seen so far is promising – particularly as it relates to improving modularity, reducing brittle dependencies, and preparing IDEs to onboard lightweight, contextual agents.
Early software development kits (SDKs) and examples are beginning to emerge. From simple file system wrappers to more advanced use cases embedded in Anthropic’s Claude models, these examples are giving us reference points for what adoption might look like in practice.
For us, this isn’t about replacing what’s already working. It’s about unlocking new capabilities that let us adapt faster, trace actions more clearly, and support engineers with systems that are ready to help, not just store data.
Some Questions We're Asking (and You Might Be Too)
- Which of our tools could benefit from a shared interface surface?
- What mission-relevant context could we start expressing as metadata?
- How would we define an agent’s scope of action in a complex workflow?
- What policies would need to exist before we trusted agent behavior?
These are open questions, but they’re shaping our thinking and guiding where we experiment next.
A Step Toward Smarter, Safer Integration
MCP isn’t promising magic. For now, it still takes engineering. It still requires governance, digital rules of engagement, and it still faces the challenge presented by legacy and commercial off-the-shelf (COTS) digital engineering tools that will need MCP adapters or semantic mapping to enable participation in our IDE.
Perhaps most importantly, it doesn’t alleviate the need to drive real cultural change, encouraging new behaviors, workflows, and trust models that allow us to fully realize the promise of digital integration. But it does offer a language we can start using to compose our environments differently.
It does let us move from tightly coupled pipelines to interoperable services. From brittle automation to contextual, policy-bound agents. From fragmented tools to mission-aware environments.
That’s a direction we’re excited to pursue with the operational mission always in mind.
Because in the end, our goal isn’t just digital modernization; it’s to deliver readiness – faster, with confidence, and with tools we trust.