Back in November 2025 I wrote about the Engineering Super Stack: MATLAB, Visual Studio Code, and Claude Code wired together with the MATLAB MCP server. The thesis was simple. These tools are better together than apart.
Five months later, I owe that post an update. The stack evolved.
The Agent Engineer
Seth DeLand has been at MathWorks for fifteen years. He started in mechanical engineering, building mathematical models for diesel combustion and NOx emissions. Control strategies, optimization, statistics. The kind of work where getting the math wrong means the engine doesn’t meet spec. Now he’s a Product Manager focused on generative AI, and he recently sat down with Jousef Murad on the Engineered-Mind Podcast to talk about what agentic AI means for engineers.
He’s not selling hype. He’s describing what he sees happening in real engineering workflows.
On what makes agentic AI different from chatting with an LLM:
“Rather than it just generating a bunch of text, it’s actually going to generate calls to APIs… now they’re not limited just to generate text as an output, they can actually start to work on the same artifacts that we humans are working on.”
Seth DeLand
That distinction matters. An LLM gives you text. An agent gives you results. It runs your code, checks your tests, detects your toolboxes, and iterates on errors. No copying and pasting between windows. The agent works on your project, not a hypothetical version of it.
Seth didn’t frame this as tools replacing engineers. He framed it as engineers leveling up.
“It’s more that we are working at a higher level now. We are thinking much more in terms of what are the problems, what are the constraints, how do I shape the solution space so that I can turn my AI loose in that solution space and have it go work… and then come back to me.”
Seth DeLand
You’re not being replaced. You’re being promoted. The engineer becomes the one who defines the problem, sets the constraints, and shapes the space where the AI works. That’s not a demotion. That’s what senior engineers have always done, except now the junior engineer on your team is an agent that never sleeps and never complains about the build system.
Seth also nailed something I’ve been feeling since I started using agents for prototyping:
“Why not have it implement four prototypes of all of those different options and see which one I like the best… it allows me to shorten that cycle to get from kind of an idea to some type of proof of concept.”
Seth DeLand
Four prototypes. Not four design docs. Four working implementations. You compare running code instead of arguing about architecture diagrams. I wrote a whole post about this idea (Twenty Prototypes), and hearing a MathWorks PM describe the same workflow independently tells me this isn’t a niche trick. It’s becoming the default.
What Changed Since November
When I wrote the original super stack post, the MATLAB MCP Core Server was at version 0.1. First release. Five tools. It worked, but everything is moving fast.
Here’s where things stand now:
The MCP server is at v0.6.1. MathWorks shipped cross-platform MCP Bundles for one-click installs, added headless mode so MATLAB can run without the desktop GUI, and introduced MCP Resources that feed coding guidelines directly to your AI agent. Nine releases in five months.
MATLAB Copilot launched with R2025a in May 2025. It’s a purpose-built AI assistant inside the MATLAB desktop with chat, code generation, autocomplete, and error explanations. They even upgraded the underlying model to GPT-5 mini a month after launch.
Simulink Copilot entered beta. You can chat with your Simulink models, search and trace features with natural language, and troubleshoot errors through a dedicated panel on the canvas. If you do model-based design, this is worth watching.
And the MCP ecosystem around it exploded. MCP now has 97 million monthly SDK downloads and over 10,000 active servers. Anthropic donated it to the Linux Foundation. OpenAI, Google, Microsoft, and Amazon all support it. MathWorks calls MCP “USB-C for AI,” and that metaphor has held up.
The super stack isn’t experimental anymore. It’s infrastructure.
The Setup: MATLAB MCP + VS Code + GitHub Copilot
The original post showed the stack with Claude Code. This time I’ll set it up with GitHub Copilot in VS Code. Same MCP server, different AI client. That’s the whole point of an open protocol.
What you need:
- MATLAB R2020b or later, installed and on your system PATH
- Visual Studio Code with the GitHub Copilot Chat extension
- The MATLAB Extension for VS Code (optional but recommended)
- A GitHub Copilot subscription (the free tier works)
Step 1: Download the MCP server
Go to the MATLAB MCP Core Server releases page on GitHub and download the binary for your platform:
- Windows:
matlab-mcp-core-server-win64.exe - macOS Apple Silicon:
matlab-mcp-core-server-maca64 - macOS Intel:
matlab-mcp-core-server-maci64 - Linux:
matlab-mcp-core-server-glnxa64
On macOS or Linux, make it executable: chmod +x matlab-mcp-core-server-*
Step 2: Configure VS Code
Create a .vscode folder in your project root (if it doesn’t exist), then add an mcp.json file:
{
"servers": {
"matlab": {
"type": "stdio",
"command": "C:\\path\\to\\matlab-mcp-core-server-win64.exe",
"args": [
"--matlab-root=C:\\Program Files\\MATLAB\\R2025a",
"--initial-working-folder=C:\\Users\\you\\YourProject"
]
}
}
}Replace the paths with your actual MATLAB installation and project directory. On macOS or Linux, use forward slashes.
Step 3: Validate
Open GitHub Copilot Chat in VS Code and ask: “Which MATLAB toolboxes are available?”
If everything is wired up, the MCP server launches MATLAB in the background and Copilot responds with your installed toolboxes. The first call takes a few seconds while MATLAB starts. After that, it’s fast.
What you get:
Five tools, available to any MCP-compatible AI client:
detect_matlab_toolboxes: Lists your installed MATLAB version and toolboxescheck_matlab_code: Runs static analysis on a .m file (style issues, errors, deprecated functions)evaluate_matlab_code: Executes a MATLAB code string and returns the outputrun_matlab_file: Runs a .m script filerun_matlab_test_file: Runs MATLAB unit tests
Plus two MCP Resources (added in v0.3) that feed your AI agent the official MATLAB coding guidelines. The agent doesn’t just write MATLAB code. It writes MATLAB code that follows MathWorks conventions. 1i instead of i for imaginary numbers. k for loop variables. Error handling the way the documentation says to.
“I think one of the impressive things about a lot of these AI models is that if you can teach it about the system that it’s working on… they can build on top of existing things that you have.”
Seth DeLand
That’s exactly what the MCP server does. It teaches the AI about your MATLAB installation, your toolboxes, your project. The agent isn’t guessing. It’s building on what you already have.
You Are the Engineer
The tools got better. The MCP server matured. The ecosystem grew. But the most important upgrade in the super stack isn’t software.
It’s you.
You decide what problem to solve. You set the constraints. You shape the solution space and turn the agent loose inside it. When it comes back with four prototypes, you’re the one with the engineering judgment to pick the one that actually works for your system.
The agent writes code, runs tests, checks for deprecated functions. It can’t decide what matters. That’s your job.
Seth put it well: engineers are working at a higher level now. Not because the tools forced them to, but because the tools finally caught up to where the interesting problems live. The math. The constraints. The design decisions that determine whether the system works when it meets the real world.
The super stack is MATLAB, VS Code, and an AI agent connected through MCP. The stack doesn’t work without the engineer at the top of it.