Connecting Agentic Workflows: GT-SUITE’s MCP Integration

Simulation engineers now have no shortage of AI tools, but each one works in isolation. A coding assistant cannot see inside the simulation model. The simulation tool cannot talk to the project tracker. So, the engineer becomes the connective tissue: copying an output from one window, pasting it into another, manually bridging the gaps each tool leaves behind.

Meanwhile, the simulation environment itself remains locked behind a GUI and a scripting layer that demands deep, specialized fluency. An engineer will need to know which attributes to call, which APIs to invoke, and how parts connect. Even experienced engineers will need to spend significant time to understand a codebase before they can change it, time that no AI assistant, working in isolation, can reclaim for them.

That is the real bottleneck: not a lack of AI tools, but a lack of connection between them. That is what the Model Context Protocol changes.

What Is Model Context Protocol?

The Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external tools and data sources in a structured, secure way. Think of it as a universal adapter, instead of copy-pasting code, error messages, or model data back and forth between your AI and your engineering tool, MCP lets the AI directly interact with the tool.

AI sends a request through the MCP connection “What attributes does this component have?” or “verify the connectivity of these parts” and the tool responds with real data. AI can then act on that data, iterate, and request further verification without the user manually relaying anything.

It is a small architectural change with a large practical effect, AI stops being a sophisticated autocomplete and starts being a capable agent.

MCP Meets GT Intelligence Studio

GT Intelligence Studio (GT-IS) is Gamma Technologies’ AI platform built on top of GT-SUITE – a multiphysics simulation platform used to model complex engineering systems. GT Intelligence Studio is built around three goals: accelerating engineering productivity, improving quality, and enabling innovation. MCP extends that vision by connecting AI directly to the engineering tools, knowledge, and live simulation models engineers already use. GT Intelligence Studio provides MCP capability that exposes AI.coder, AI.advisor, and AI.modeler to MCP-compatible AI assistants.

AI.modeler is an active agent inside GT-ISE. It can create and modify model objects, set attributes, manage part connections, run simulations, and inspect the live state of a `.gtm` file. It is stateful, maintaining context across calls within a session, allowing it to reason about what it just did and act on the result, supporting not just faster workflows, but new approaches to exploring and refining models that weren’t practical before.

AI.advisor is a knowledge base for conceptual questions: how does this template work, what is the purpose of this component, or what is the recommended workflow for a given task. It draws from GT-SUITE’s documentation and help content.

AI.coder is a knowledge base for scripting questions: what is the Python API for a given operation, how do I set this attribute in a code, what is the correct syntax for connecting parts programmatically.

Together, these give an external AI assistant – a coding assistant in your integrated development environment, a custom agent, or any MCP-compatible client – a complete interface to GT-SUITE with conceptual understanding, API guidance, and the ability to act on a live model. Instead of generating code and hoping it matches your specific model’s API, AI can now ask first, write grounded code, catch errors in context, and verify the result, all without the engineer manually relaying anything.

The MCP server exposes AI.modeler, AI.advisor, and AI.coder as a single interface between an AI assistant and a live GT-SUITE model, enabling it to query context, act on the model, and return results in one continuous loop.

Use Case: The Agentic Development Loop in Action – Extending an Automation Script

A concrete example of this workflow in action follows:

The task: extend an existing, working Python automation script to support new model components and logic, adding new parts, attributes, and connection behavior, without breaking what was already in production.

This kind of task is common in simulation engineering. Teams build scripts to automate model construction, run parameter sweeps, or post-process results. Over time those scripts grow and extending them requires understanding both the existing code and the GT-SUITE API well enough to add new behavior safely. Getting an attribute’s name wrong, missing a port, or accidentally duplicating a function silently corrupts results or causes hard-to-trace failures. The engineer normally spends significant time reading the automation manual, tracing the existing codebase, and manually verifying each change.

With GitHub Copilot in VS Code connected to GT-IS via MCP, the workflow looked like this:

Schema discovery: Before writing a line of code, Copilot queried GT-IS through MCP to understand the model’s structure. AI.advisor answered conceptual questions about the templates and components involved. AI.coder returned the exact Python API signatures, attribute names, and port definitions for the new components. No manual lookup of the automation manual. No guessing.

Coding loop: With the schema in hand, Copilot wrote the script and executed it. When errors came back from the terminal, Copilot sent them to AI.coder via MCP, which analyzed them against the GT Python API and returned targeted debugging guidance. Copilot refined the code and re-executed. This loop – write → run → get contextual feedback → refine – ran until the script executed cleanly.

Testing loop: Once the script ran without errors, Copilot invoked AI.modeler through MCP to verify the result. AI.modeler understood the `.gtm` file, inspected part placement and connectivity in the live model, and returned a structured summary confirming the new components were correctly integrated and nothing existing had broken.

Reporting: The verification summary was compiled into a test report and logged in the team’s project tracker via MCP, closing the loop from problem statement to documented, verified deliverable.

Copilot in VS Code connects to GT Intelligence Studio’s three AI capabilities over MCP, with AI.modeler reading and writing GT-ISE files directly and results logged back to the project tracker.

Why This Is Different

A code assistant without tool access gives you suggestions based on training data. It does not know your specific model, your port definitions, or which functions already exist in your codebase. It makes reasonable guesses, and you verify them.

With MCP, GT-IS becomes a live source of truth in the loop. The AI is not guessing at your API, it is querying it. It is not hoping the connectivity logic is right, it is verifying it. The feedback it gives is grounded in the actual state of the model, not in a general understanding of how GT-SUITE works.

This also keeps the scope narrow by design. GT-IS exposes specific, scoped capabilities over MCP – AI.advisor for conceptual guidance, AI.coder for API and scripting knowledge, AI.modeler for live model actions – rather than open-ended access. The human engineer reviews outputs and makes decisions; the AI handles the retrieval and iteration work that used to fall on the engineer’s plate.

The result is not a replacement for simulation expertise. It is a collaborator that can actually use your tools.

What’s Next

The Python development workflow shown here is one of the several use cases enabled by GT-IS’s MCP integration. The same architecture supports model building from natural language, results analysis, and design exploration – anywhere an AI agent benefits from direct, live access to simulation state.

GT-IS operates as both an MCP server (to user interfaces) and an MCP client (to external tools such as math solvers and post-processing engines), enabling it to participate in a broader AI ecosystem.

The connection also runs in the other direction. AI.modeler is not only an endpoint that external tools call into, but it can also act as an MCP client, reaching out to other MCP enabled servers in your toolchain. That means AI.modeler can pull data from external math or optimization tools, exchange information with other simulation environments, or integrate with any MCP-compatible service your team already uses. GT-IS becomes a participant in a broader connected ecosystem, not just a standalone endpoint. The simulation expert isn’t being replaced, they’re getting a better-equipped collaborator.

Discover how GT Intelligence Studio can accelerate your own modeling workflow. Visit the GT Intelligence Studio product page to learn more about AI.advisor, AI.coder, and AI.modeler, join our LinkedIn community to stay updated on simulation-driven workflows, and contact us to see a walkthrough. Subscribe to the GT blog to receive updates on new AI capabilities, engineering solutions, and industry trends.