Fine for a side-project web app. Does not work for an inverted pendulum spinning on your desk.

The Pit and the Pendulum

MathWorks just published a Tech Talk by Brian Douglas. It is worth watching if you build hardware.

The setup is a Quanser cube servo with an inverted pendulum, a Raspberry Pi running the controller, and a coding agent wired into Simulink through the Simulink Agentic Toolkit. The agent’s job is to swing the pendulum up and balance it.

Balancing an inverted pendulum is a classic control problem because it’s unstable by nature. Get the math wrong and the pendulum falls. Get the code wrong and a 12V motor jerks the cube into something it shouldn’t.

What Happens If You Just Prompt It

The tempting move is the one most of us have done with web apps. Open a chat, describe the system, ask for the code. One prompt, big blob, ship it.

The MathWorks engineers walk through why that falls apart for hardware:

“If you rely on AI to generate code directly, that process is much less structured… it’s often unclear exactly how or why a particular implementation was created, making it harder to trust and verify.”

Brian Douglas

Hardware is unforgiving. You can’t roll back a destroyed motor with a git revert. When a physical system fails, you need to know which assumption broke, which equation got the wrong constant, which sample rate the controller is actually running at. A black box of generated C code doesn’t tell you any of that.

“You don’t want to let your AI agent skip parts of your engineering workflow. That’s how you can get yourself into trouble with a final product that doesn’t meet your objective or worse, is just purely unsafe.”

Brian Douglas

The Workflow Is the Script

The answer is to keep the AI inside the workflow engineers already trust: Model-Based Design. The agent doesn’t replace the workflow. It runs each step inside it, faster.

Define quantifiable requirements. Before any code, the human and the AI agree on what success looks like. Spin-up speed. Wobble limits. The 12V motor constraint. These targets become the benchmarks for verification later.

Use a trusted model. Instead of letting the AI invent a custom physics engine, the workflow points it at an existing Simulink model. The agent runs linearization through the Simulink Agentic Toolkit and reports the system’s poles back to the human. The math comes from validated tools, not from a language model freestyling differential equations.

Use a trusted controller. Same logic. The agent is told to use the MPC Toolbox. Model Predictive Control has decades of theory behind it and a deterministic implementation. If something looks wrong, you can tune it manually. You’re not debugging an optimizer the AI invented on the fly.

Verify in layers. Three stages before the code touches hardware:

• MIL (Model-in-the-Loop): the controller runs against the theoretical model
• SIL (Software-in-the-Loop): the generated embedded C code runs on a computer, behaving exactly like the simulation
• PIL (Processor-in-the-Loop): the C code runs on the actual target Raspberry Pi

Each layer catches different bugs. Skip one and you’ll catch that bug on hardware instead.

Deploy and iterate. Only after layered verification does the code go on the real pendulum.

“Instead of asking an agent to solve your problem however it wants, you tell it to follow an engineering workflow that you understand.”

Brian Douglas

The AI executes. The human directs.

The Hardware Truth

Here’s the part of the video I liked best. They ran the verified controller on the real pendulum and it didn’t quite work. The physical hardware behaved differently from the model.

This is what the vibe-coding fantasy ignores. Reality disagrees with simulation, especially the first time. You will need to iterate. The thing that matters is whether you can.

Because the team followed the workflow, they could. The model was traceable. The requirements were quantifiable. The controller was inspectable. They used the AI to update the physics model, ran it back through MIL, SIL, and PIL, and tried again. No starting over.

The workflow doesn’t promise perfect code on the first pass. It promises code you can fix.

The Director Pattern

A few months ago, I wrote about Seth DeLand’s framing of agentic AI for engineers. The headline idea: 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.

The MathWorks Tech Talk is what that looks like in hardware. The AI isn’t the engineer. It’s the agent. You’re the director.

“Agentic AI is powerful, but for engineering, the value comes from how you use it. You get the speed and productivity benefits of AI without sacrificing trust, safety, or understanding.”

Brian Douglas

You don’t get speed and safety together by handing the AI a prompt and crossing your fingers. You get there by keeping the workflow you trust and letting the agent move faster inside it.

Speed without losing safety. Productivity without losing traceability.

For software, vibe coding is mostly fine. The blast radius is a wasted afternoon.

For hardware, the blast radius is a sparking motor and a pendulum on the floor.

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!