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 toolboxes
• check_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 output
• run_matlab_file: Runs a .m script file
• run_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.

Here’s how I feel rn.

I really feel like I can engineer anything with this setup, helping me build engineered systems. I have tried new toolboxes, built deep learning projects, and improved my MATLAB coding skills by running AI code reviews.

“Using MATLAB + Claude Code went from ‘vibe coding’ to ‘vibration engineering’ — I was no longer just using AI — I learned from it, got pointed in the right direction, and dug in.

Hans Scharler

Here is what you need:

• MATLAB: https://matlab.mathworks.com
• Visual Studio Code: https://code.visualstudio.com/
• Claude Code: https://www.claude.com/product/claude-code
• MATLAB MCP Core Server for Claude Code: https://github.com/matlab/matlab-mcp-core-server
• MATLAB Extension for Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=MathWorks.language-matlab

To build your own super stack, open a new MATLAB project in Visual Studio Code with the MATLAB and the Claude Code extensions enabled. From a terminal in VS Code, run Claude Code. Claude Code will interact with Visual Studio Code via these extensions. In Claude Code, enable the MATLAB MCP Core Server. This will give you five MCP tools to interact with MATLAB. Claude Code will be able to check code, evaluate code, run files, run test files, and detect your local MATLAB’s toolboxes.

In my vibration project, my team and I created a few files. It has been a minute since I used them, but with Claude Code, I can just get going. It is going to read what I have, learn from he documentation, and do whatever I am looking to do.

Use the vibration model to generate three weeks of vibration data, then use the analyze vibration function to detect any anomilies

What’s great about this workflow is that Claude Code is “not making up” a solution; it is leveraging the models that I have built plus constrained in MATLAB, bringing some engineering rigor to the chat. Claude Code is taking advantage of the Signal Processing Toolbox and how it works, rather than trying to figure out signal processing with some scratch code.

One extra benefit of this engineering stack is that I find myself exploring more, trying out other features of MATLAB that I haven’t used before. I feel way more confident trying something new and then learning how it works. I keep expanding what I know and onboarding into new things, learning, and gaining more experience rather than settling for a static picture. Dynamic.

WHat are your pro tips?

The core of the book is structured around practical applications that show you how and why you would want to use MATLAB and Python, and Python with MATLAB. Executing Python code inside of MATLAB, calling Python community packages, and debugging Python code that MATLAB calls are examples of advanced topics that Yann covers and gives you a sense of how easy it is to extract the value from both platforms. The book also explores the use of Python AI libraries from MATLAB, highlighting applications with Scikit-learn and TensorFlow. Conversely, it guides readers on using the MATLAB Engine API for Python, showcasing how MATLAB’s powerful tools can facilitate AI development. In a recent update to the GitHub repo that backs the book, Yann offers resources on accessing Python packages in MATLAB Online.

I found the book practical and easy to follow. My favorite part is that the book itself is open-source. The full prose and source code are stored on a living GitHub repo that Yann has been keeping up to date as things change with MATLAB and Python. Since it is on GitHub, he can link the book to MATLAB Online, where anyone can follow along and try the examples. I specifically like the Call TensorFlow from MATLAB example in the Call Python AI Libraries from MATLAB chapter.

If you are into scientific computing and want to go to the next level, I recommend that you check out the book. You can get into it right now by reading and using the examples on the GitHub repo or getting a physical copy from Amazon so that you can enjoy it at your leisure. Maybe read it with some turkey and cranberry sauce.

Bonus Video

If you want to hear and see Yann talk about Python and MATLAB in a video, you are in luck. Yann was a guest on the MATLAB Coders YouTube channel and got into how to effectively use Python and MATLAB together. I like to think that this presentation was the beginning of Yann’s dream to write a book.

To get started, open the MATLAB AI Chat Playground in your favorite desktop web browser. Select an onboarding prompt or type in a question, an idea, or a request for code.

The AI returns explanations, code, and ideas for how to continue the conversation. You can run the code in real-time thanks to the MATLAB Online compute server. You can rate the output using the thumbs-up or thumbs-down buttons. This helps us tune the experience over time.

I have been living with the AI Chat Playground since May and learning with a group of community users. I try to use the playground for my MATLAB questions and work instead of using a search engine. The playground does not do the work for me, but it does help me get closer to a solution. The idea is to accelerate learning and building. If I shave some minutes off looking for an example or answer, then I can stay in the zone longer. These minutes add up over the course of a day, a week, a month, or a year—just little efficiencies that pile up.

My old friend, Jay, called me on his commute the other day, and he said something that has been sticking with me all week.

“This is the worst that Generative AI technology will ever be.”

Jay Huie

Right now, ChatGPT from OpenAI, Bard from Google, and Poe from Anthropic are already amazing large-language models. It is crazy to think that this is the worst version of the technology, and that is only up from here. We have been living in this world for about 11 months. Buckle up.

So, over to you. Head over to the MATLAB Central community to access the AI Chat Playground. Let me know what you learn or build. And share with the rest of the community in the MathWorks Community Discussion Area for Generative AI.

Most people experienced MATLAB on their PC, but you can also access MATLAB in your browser with MATLAB Online. MATLAB Online is a web-based version of MATLAB that allows users to access the software and its features through a web browser. It eliminates the need to install and configure the software on a local computer, making it accessible from anywhere with an internet connection.

In this project, I will be using MATLAB Online to take a picture with a webcam, classify the image using a pre-trained deep learning model, and display the results.

I selected the ResNet-50 model, which is a deep convolutional neural network (CNN) trained on the ImageNet dataset. ResNet-50 stands for “Residual Network with 50 layers” and was developed by Microsoft Research in 2015. The architecture is known for its ability to train very deep neural networks without the problem of vanishing gradients, which allows for improved performance on image classification tasks. The model is capable of identifying objects in images and classifying them into one of 1000 different categories.

% Connect to webcam
cam = webcam;

% Take a picture
img = snapshot(cam);

% Resize image to [224 224 3]
img = imresize(img, [224 224]);

% Display the picture
imshow(img);

% Load pretrained model
net = resnet50;

% Classify image
label = classify(net, img);

% Display label
disp(label);

% Release webcam
clear cam;

What’s really neat is that MATLAB Online can use your webcam. This code takes a photo, resizes it for ResNet-50, shows the output, and classifies the photo.

Check out MATLAB Online and run the very latest version of MATLAB and select toolboxes. Everyone should be able to try this project out and get started with image classification.

The Problem

Daily Fantasy Sports (DFS) for football is about picking a lineup of players across all of the NFL teams under a set salary cap and competing against other players doing the same thing. It’s easy right? Just pick all of the best players! Profit. Wait up. Everyone else is doing that too. The secret is to use player projections, maximize your utility of the salary cap, and add some chili pepper for your signature taste.

The Solution

Dust off your math skills and remind yourself that everything is a math problem, but others have solved them for you. An optimal DFS lineup is just an optimization problem. I am going to pick optimal DFS lineups using MATLAB and its Optimization Toolbox.

Get the Data

In order to optimize a lineup, you need to get some data. You need a table of players with their positions and score projections. I recommend getting the latest player projects from Daily Fantasy Fuel. They give you access to a table with everything that you want and they update it daily with the latest projections from Draft Kings and Fan Duel. Projections are subjective but they take into account past performance, team matchups, and weather conditions. You can adjust each row of the table with your own projections and put your thumb on the scales so to speak. Maybe you got some insider info that the Rams are not going to start Cam Akers so you adjust their projection down.

• Go to Daily Fantasy Fuel and click on “Download Projects as CSV”
• Save the file to your computer as “DFF_data.csv” into a new folder

A CSV file is just way to save data as a table. It might look intimidating if you open it up, but we are going to import the data into a nice clean table using MATLAB’s import tool.

Access MATLAB

You might have MATLAB installed on your computer, so all you have to do is open MATLAB. If you don’t have MATLAB installed, you can use MATLAB Online at matlab.mathworks.com by signing in and clicking “Open MATLAB Online (basic).”

Import the Data

First, we need to get the data into MATLAB.

• Right-click on the “Current Folder” and click “Upload Files”
• Select the CSV file that you downloaded from Daily Fantasy Fuel

Second, we need to import the data from the CSV file so we can work our fantasy magic.

• Right-click on the DFF_data.csv that we uploaded and click Open
• Click “Import Selection” and “Import Data”

These steps will bring the data into MATLAB in a nice and useable way. All of the default options will work perfectly.

Enter the Code

First, let’s create a new file for our optimizer code.

• Right-click on the Current Folder area, click New, and then Live Script
• Name it “dfs.mlx” and open it

Next, we need to get the code into MATLAB.

• Copy and paste my MATLAB code from GitHub into your new MATLAB Live Script.
• Click “Save”

The next thing that we need to do is select a “Salary Cap” and run the code.

• Change the salaryCap variable to the salary cap to optimize for. 50,000 to 60,000 is a common range.
• Click the Run button on the Live Editor tab

If everything goes to plan, MATLAB will output a table of optimal starting players based on the projected data.

Profit

There’s still some luck involved. Projections are projections. Now that you have a baseline, you can experiment by using different projections data and tweaking individual player projections.

Let me know how you do and if you made some improvements to my optimization code. Good luck.

Resources

• Source code at GitHub – https://github.com/nothans/dfs-optimizer
• Daily Fantasy Fuel – https://www.dailyfantasyfuel.com/nfl/projections/
• MATLAB – https://matlab.mathworks.com/
• Optimization Toolbox documentation – https://www.mathworks.com/help/optim/

Recently, my college at MathWorks, Christopher Stapels, introduced me to the Raspberry Shake. The”shake” is a personal seismograph that laterally allows you to watch the Earth move and the things that cause the earth to move.

Christopher went on to collaborate with Alan Kafka at Weston Observatory, Boston College, and Jay Pulli at Raytheon to explore traffic data analysis using seismic data collected by the Raspberry Shake and sent to ThingSpeak.

The team explored the data using MATLAB and tried to establish some correlation between vibration and traffic density. Check out the project on the MathWorks IoT Blog. Whole Lotta Shakin’ Goin’ On.

The coding contest is all about using 280 characters or less of MATLAB code to show off an interesting and beautiful image. We will be displaying all of the images allowing folks to remix the code and make new ones. As part of the celebration, MathWorks will be donating up to $20,000 to the humanitarian aid organization, Direct Relief, based on participation. Along with the support of Direct Relief, we will be giving winners a custom MathWorks shirt. I WANT THIS SHIRT!

Check out the MathWorks Community Contests at MATLAB Central. Follow along for news and updates. And, if you win, show off your t-shirt.

Butterflies have recently captured George’s attention.

It was fun exploring the lifecycle of a butterfly going from eggs to a caterpillar to a pupa to finally a beautiful butterfly. I am sure there are life lessons in this metamorphosis, but that is for another day.

George learned by observation. I learned by observation. Butterflies have a unique flight path. They have had a lot of time to learn how to fly and they treat the air like water. What can we learn from butterflies? Well, to go next level, you need some butterflies, a wind tunnel, and some high-speed cameras to slow down the butterfly’s motion and see what they are doing with their wings. Researchers at Lund University did just that.

In a complex experiment, the researchers used MATLAB to calculate aerodynamic forces and analyze the butterfly kinematics. They discovered that the butterflies’ flexible wings provide the impulse and increased efficiency that results in their distinct flight pattern.

It turns out that the butterfly wing is flexible. This allows the butterfly to form a cup to create a tremendous amount of thrust. Planes, jets, and drones all have rigid wings. Understanding how butterflies fly could lead to innovations with other flying machines.

Read more about the butterfly project on MathWorks.com. Science!

Our Ninja Foodi Air Fryer became our family’s go-to gadget during the stay-at-home order. When you order takeout, you probably noticed that the food isn’t the same. The plastic containers are nice for containing during transport, but they have a side effect of steaming your food. Pop your sides into an air fryer and they are back to their former glory… and sometimes even better. We also found a bunch a recipes made for the air fryer. This is going to change your whole existence and I never, ever use hyperbole.

A few years ago, I worked on a predictive maintenance project for duct fans. An air flyer is like a normal oven with the addition of a fan. There are fans in almost every major system and when they fail, the system that they are attached to will eventually fail. Fan blades can get bent, dusty, covered in food particles and oils, and damaged over time. The idea behind predictive maintenance is to predict the remaining useful life (RUL) of a machine and perform maintenance and repairs just-in-time. When applied at scale, predictive maintenance strategies provide a substantial return on investment. Studies show that condition-monitoring and predictive maintenance pays for itself and can be developed by anyone using MATLAB and the Predictive Maintenance Toolbox.

Check out my Condition-based Maintenance of a Duct Fan using ThingSpeak over at Hackster for a complete tutorial, video, and the source code. I adapted this project for an air fryer, but you could literally apply this technique to any machine that you want to monitor or to predict its remaining useful life. The idea is that fans and monitors vibrate when they are operational. As they degrade, the vibration changes over time. If you train a model with the data, you can use the model to predict the machine’s state, condition, and remaining lifespan. The predicted information can be used to change the maintenance schedule of the machine and optimize repair timing. It’s better to replace a part when the machine is scheduled to be down versus when the machine is in production.

I am using the Particle Internet Button for this project. The button gives me a nice convenient packaging of a Wi-Fi device for connectivity to ThingSpeak, an accelerometer to measure vibration, and LEDs for status lights.

The system uses ThingSpeak channels to store the vibration data, MATLAB / Predictive Maintenance Toolbox to build our machine learning model, MATLAB to analyze live data, and ThingSpeak to visualize our machine state and predictions.

Here’s an overview of the steps involved:

• Data Collection – Your first challenge is to collect data from the system. Attach the vibration sensor package to the machine, connect it to the network, and send the data to an IoT service like ThingSpeak.
• Data Parsing, Exploration, Feature Extraction, and Training – Now that you have data, you have to figure out what it all means. Use MATLAB, the Predictive Maintenance Toolbox, and the Statistics and Machine Learning Toolbox to parse the data, extract interesting features, and to train a machine learning model.
• Visualize and Report – Present your findings with charts and gauges. Use ThingSpeak Alerts to send automated email messages about the machine’s health.
• Profit.

Here’s what some raw data from air fyer looks like.

Vibration data is hard to interpret, but with machine learning, it’s possible to classify what the vibration data means and understand what the changes mean over time. You may even have noticed the sound of these appliances change over time. This is your brain picking up on the changes and telling you, “IT IS TIME TO CLEAN YOUR NASTY AIR FRYER.” Imagine a machine learning model always monitoring the vibration data and alerting you on the changes. Things will be working when they are supposed to be working.

Run two experiments with your fan and collect the data:

• Experiment 1: Simulating failure due to blocking the airflow (1000 data points) – Collect 1000 data points: 250 – OFF, 250 –ON, and 500 – BLOCKAGE
• Experiment 2: Simulating failure due to rotor imbalance (1000 data points) – Collect 1000 data points: = 250 – OFF, 250 –ON, 500 – IMBALANCED

When we explore the vibration data, you may notice some things:

• The variance of the data in the time domain increases as the fan is turned on and as the failure develops in both experiments.
• In the frequency domain for the experiment 1 data, the peak shifts from 30 Hz to 25 Hz.
• In experiment 2, the peak in the frequency domain remains at the same point but the amplitude at that frequency increases.

Using MATLAB’s built in Classification Leaner App in the Statistics and Machine Learning Toolbox makes it easy to train a machine learning model with your data.

When everything is running in operation, the system will monitor the vibration data, analyze using the MATLAB analytics that we developed in the tutorial, and predict the time to service. As you use appliances and machines they degrade over time. You don’t always need to clean and maintain. The trick is to do it when you need to do it before catastrophic failure… or going to Amazon and buying a new one.

If you are looking to try this out for yourself, check out the Condition-based Maintenance of a Duct Fan project published on on Hackster. We have included the source code for the device as well as the MATLAB code to make the system to work. This can be applied to other systems and the process applies to many applications of predictive maintenance. Now that you know that these techniques exist, you might be able to find some useful ways to apply them.

Apparently, I like connecting appliances to the internet.