Artificial Intelligence

Less Typing, More Creating: MATLAB Copilot Comes to Your Android Phone

Yann Debray — Tue, 07 Apr 2026 14:07:52 +0000

Guest Co-author: Tharikaa Ramesh Kumar, PhD

Tharikaa is the Product Manager for MATLAB Mobile. She holds a PhD in Aerospace Engineering from Auburn University, where she taught dynamics and systems courses using MATLAB as a graduate instructor.

I'm excited to share some news that I think will change the way many of you use MATLAB on the go. We've brought MATLAB Copilot to MATLAB Mobile, and it's available for now on Android with two features: Copilot Chat and Explain Code. If you've ever been on a commute, in a lecture hall, or out in the field and wished you could quickly prototype an idea in MATLAB, you know the challenge. You pull out your phone, open MATLAB Mobile, and start typing on a small touch keyboard. It works, but it's not exactly the same as sitting at your desk. That's where Copilot comes in.

Why an AI Assistant on Your Phone Changes Things

Let's be honest: coding on a phone has its limitations. The screen is smaller, the keyboard is touch-based, and switching between your code and documentation is a juggling act. MATLAB Copilot reduces that friction significantly.

With Copilot Chat, you describe what you want in natural language and get MATLAB code you can run right away. Instead of typing out every function call and argument, you tell Copilot what you need and it writes the code for you. Less typing, more creating!

Here is a bonus: your phone keyboard already has a microphone button for speech-to-text. Tap it, speak your Copilot prompt, and the code appears. You do not even need to type your request. Between voice input and AI-generated code, this is as close to a low-code experience as it gets on a phone. And when you do type, your phone keyboard's predictive text and autocomplete suggestions help you write prompts faster than you would on a desktop keyboard.

For the many students and educators who use MATLAB Mobile every day, this is especially valuable. Your phone is the one device that's always with you and always charged. It's more personal and more accessible than a laptop. With Copilot on that same device, you get answers and explanations on the spot, right where you are, instead of waiting to get back to a computer.

Copilot Chat

Copilot Chat is a conversational AI assistant built right into MATLAB Mobile. You can access it from the Command Window, the Editor, or the app menu. Ask a question, describe the code you need, or request an explanation. Copilot responds with answers grounded in MathWorks documentation.

Here is where it really shines on mobile. Say you've just collected accelerometer data from your phone's sensors using MATLAB Mobile's built-in sensor support. You want to plot the x, y, and z axes on a single figure, but you can't remember the exact syntax. Open Copilot Chat and describe what you're looking for. Copilot generates a ready-to-run snippet that handles the plot calls, axis labels, and legend for you. Tap to insert the code, hit Run, and you're looking at your data.

It works just as well for broader questions. If you're wondering how to apply a low-pass filter to audio you recorded on your phone, ask Copilot. Need a quick refresher on how fft works? Ask Copilot. It handles everything from basic syntax help to signal processing workflows, and every response draws from official MathWorks documentation so the code follows best practices.

As with all things GenAI, your results will depend on your specific question and context.

Explain Code

The second feature we're bringing to MATLAB Mobile is Explain Code. Select any block of code in the Editor, tap Explain Code, and get a plain-language overview of what the code does along with a line-by-line walkthrough in the Chat panel.

On a small screen, dense code can be tough to read. Explain Code helps you make sense of it quickly. Say you open a shared script from MATLAB Drive, maybe a classmate's assignment or an instructor's demo file, and encounter a block of code using fft, windowing functions, and inverse transforms. Instead of switching apps to search the documentation, select the code and tap Explain Code. Copilot gives you an overview of the block's purpose and annotates each line so you understand not just what the code does, but how.

This is incredibly useful for learning. Students can review code before an exam and actually understand each line. TAs can quickly parse student submissions between classes. Professors can pull up a demo script and get a refresher before a lecture. All from their phone.

When Will You Use This?

The student on the bus. You're reviewing the signal processing examples your professor shared on MATLAB Drive. You select the Fourier transform code block, tap Explain Code, and get a line-by-line breakdown. By the time you arrive, you understand exactly how the frequency domain conversion works.

The professor between classes. A student messages you about an error in their script. You open MATLAB Mobile, describe the issue to Copilot Chat, and get a suggested fix. Share the chat history directly through your phone's messaging apps, or save it as a .txt file to MATLAB Drive for later reference. No laptop needed.

The engineer in the field. You're collecting magnetometer data with MATLAB Mobile's sensor support and want to visualize the magnetic field direction. You ask Copilot Chat how to create the visualization. It generates the code, you run it on the spot, and you see results immediately.

And here is the thing: none of this work is stuck on your phone. Every script you create with Copilot syncs to MATLAB Drive, so you can start prototyping on the bus and pick up right where you left off on your desktop. Copilot on your phone is not a separate experience. It is part of the same workflow.

We hear from students and researchers all the time that their phone is always with them, even when their laptop isn't. Now, MATLAB Copilot is right there too.

How to Get Started

Getting started takes just a few steps:

Install or update MATLAB Mobile from the Google Play (Android). The app is free to download.
Check your MATLAB Copilot license. You'll need a MATLAB Copilot license to use Copilot Chat and Explain Code. Many university campus-wide licenses already include MATLAB Copilot. Check with your institution's MATLAB administrator. Individual and team licenses that include Copilot work as well.
Start using it. Open MATLAB Mobile and access Copilot Chat from the Command Window, the Editor, or the app menu. To try Explain Code, select code in the Editor and choose "Explain Code." That's it.

For more details, visit the MATLAB Copilot documentation and the MATLAB Mobile product page.

Try It Out

We've been looking forward to getting this into your hands. Update MATLAB Mobile, open Copilot Chat, and ask your first question. I think you'll be surprised how quickly it becomes part of your workflow.

We'd love to hear how you're using MATLAB Copilot on Mobile. Drop a comment below or share your experience with #MATLABMobile.

Advanced Battery State of Charge Estimation with AI

Yann Debray — Mon, 06 Apr 2026 13:55:44 +0000

Guest writer: Riccardo Di Dio

Riccardo Di Dio is an Industrial PhD Candidate sharing his time between the University of Pisa and Marelli, working on artificial intelligence methods for Battery Management Systems. His research focuses on deep learning algorithms for estimating battery internal states such as State of Charge (SOC) and State of Health (SOH), developed using MATLAB and Deep Learning Toolbox.

As a global leader in automotive technology, Marelli is driven by innovation supporting the electrification revolution. This article's aim is to show a cutting-edge solution developed for Battery State of Charge (SOC) estimation using artificial intelligence. Accurate SOC estimation is essential for Battery Management System, directly impacting vehicle performance safety and battery lifespan. Since SOC cannot be measured directly, it must be estimated using available sensor data and advanced modelling techniques. Marelli saw an opportunity to use a data driven approach powered by AI to overcome the limitations of the traditional physical models.

The article describes how the Marelli company developed the AI algorithm using synthetic dataset generated through a Virtual Environment developed using model-based design techniques in MATLAB.

The entire workflow executed using the MathWorks toolchain spans from data generation to embedded device deployment.

The MathWorks toolchain was selected due to the following reasons: visual development environment enabled intuitive graphical modeling with blocks, facilitating easy connection between the controls system and the plant model; compatibility with the Hardware in the Loop design for testing the interaction between the software and the embedded device; automatic code generation; possibility of training the algorithm in MATLAB and exporting the trained network to a real-time system.

Data Preparation

The dataset for training and validation was generated using a virtual environment repeating several times the homologation driving cycle.

The Operating Domain Definition (ODD) conditions are:

new electrochemical cell (cell with a State of Health equal to 100%)
constant temperature of 25 C and 35 C
ideality of the current sensor and the voltage sensor %[text] The inputs chosen for estimating the state of charge are the cell voltage, the cell current and the temperature. The reference state of charge is calculated using the Coulomb counting equation. All the inputs were normalized considering the operating limits of the cell (cut-off voltage, maximum or minimum current and temperature).

AI Modeling

Due to the time-related evolution of a battery's SOC, the Long Short Term Memory (LSTM) architecture was selected as the neural network. LSTM networks are particularly well-suited for capturing time-dependent patterns and sequential relationships, making them ideal for accurately estimating SOC based on historical sensor readings. The data samples were not fed to the networks individually; instead, a temporal observation window was considered.

The network was designed and trained using the Deep Learning Toolbox, provided by MathWorks, due to its powerful features for building, training and evaluating neural network models within the MATLAB environment.

A grid search technique was used to find the best performance and in particular to select the best number of neurons, the learning rate and the window size.

The Deep Learning Toolbox facilitates advanced hyperparameter tuning, making it efficient to develop and optimize complex deep learning architectures.

Real-Time Simulation

The trained network was exported to the Simulink environment to run Real-Time Testing based on different driving cycles for testing and validation, both inside and outside the ODD conditions.

The performance of the developed networks were evaluated considering the following metrics: Root Mean Square Error (RMSE), Mean Absolute Percentage Error (MAPE) and Mean Absolute Error (MAE), defined as:

$ \begin{array}{ll} \mathrm{RMSE} &= \sqrt{\frac{1}{N} \sum_{k=1}^{N} \left( Y_{\mathrm{predicted},k} - Y_{\mathrm{true},k} \right)^2} \\ \mathrm{MAE} &= \frac{1}{N} \sum_{k=1}^{N} \left| Y_{\mathrm{predicted},k} - Y_{\mathrm{true},k} \right| \\ \mathrm{MAPE} &= \frac{100}{N} \sum_{k=1}^{N} \left| \frac{Y_{\mathrm{predicted},k} - Y_{\mathrm{true},k}}{Y_{\mathrm{true},k}} \right| \end{array} $

The algorithm was validated using a drive cycle different from the WLTP employed for training and validation, in order to assess its robustness and generalization across varied and realistic operating scenarios. The performance achieved is reported in the table below.

	RMSE	MAPE	MAE
1 Simulation WLTP, no aging, ideal current and voltage sensors, 25 C	0.29	0.44	0.22

Compression

At this stage, the network contained over 10,000 parameters. To address this, a compression technique based on network projection was applied, reducing the number of parameters by 70% while ensuring that the performance of the algorithm remained uncompromised for real-world deployment.

Deployment

The last step is the C code generation of the network using Embedded Coder and the integration of the AI algorithm into Marelli's BMS architecture.

The AI algorithm embedded on a real Battery Management System hardware was tested in a Hardware-in-the-Loop (HIL) environment, which enables realistic integration between simulation and physical hardware. In this setup, the virtual environment representing the battery system dynamics was deployed directly onto the processor board of the simulator. The simulator was responsible for generating representative signals for key parameters such as voltage, current, and temperature. These signals were converted from digital to analog format using dedicated DACs and sent to the embedded device, which hosts the AI algorithm. The internal software variables of the AI algorithm were continuously monitored using ETAS INCA, allowing direct access to algorithm outputs and internal states.

The results recorded by INCA are reported in the figure below.

Conclusion

The application of AI techniques to the estimation of highly nonlinear parameters such as battery SOC has proved a powerful alternative to more classic approaches. The compression of the model enables its implementation in a real production use case. The MATLAB toolchain has provided a single workflow which has enabled accelerated design and implementation of this program - from concept to on-target implementation.

Automate the Documentation of Your MATLAB Analysis with Agentic AI

Yann Debray — Mon, 09 Feb 2026 22:04:18 +0000

Co-author: Rohan Amarapurkar

Rohan Amarapurkar is the product manager for the MATLAB Desktop and Editor. Rohan holds a Master's in Electrical Engineering from USC and previously was a UX Researcher at MathWorks.

This is a scenario that I shared with Rohan to get his advice: you finish an analysis in MATLAB, the plots look great, and now you need to share it with your team. So you start the tedious dance—export to PDF, copy the figures, write up a README, hope you didn't forget anything. And then someone asks you to tweak one parameter, and the whole process starts again.

There is now a more elegant solution, and in this blog post I am going to introduce a workflow that lets AI do the heavy lifting. With the MATLAB MCP Core Server and a few well-crafted prompts, you can go from analysis to a beautifully documented GitHub repository in minutes.

What's new	Why it matters
AI-driven documentation workflow using MCP	Your analysis, figures, and narrative stay in sync automatically
Plain-text Live Script format (R2025a)	Finally, meaningful Git diffs for Live Scripts
Export to Markdown with embedded outputs	GitHub renders your analysis as a professional README

The documentation problem

Let's admit it: documentation is often an afterthought. We write code, iterate on our analysis, and by the time it works, we're ready to move on. But good documentation is what separates a throwaway script from a reusable, shareable piece of work—especially if you're a researcher sharing publications, a student building your portfolio or an engineer looking to share your analysis with a colleague (or maybe your future self).

Starting point: your existing analysis

Most of us don't start from a blank page. We have a script that already works. Let me show you what I mean. Here's a simple analysis of the power outage dataset that ships with MATLAB (outages.csv):

It works. The plots look great. But it's just a script — no headings, no explanation of what we're finding, no narrative that a colleague could follow. This is where the MATLAB MCP Core Server comes in.

Why plain-text Live Scripts change the game

Before we dive into the workflow, let me explain why it's possible now, and why Rohan's team was instrumental in enabling it.

When we talked to Live Script users, one pain point came up again and again: the binary .mlx format didn't play well with modern development workflows. You couldn't get meaningful diffs in Git. You couldn't open your scripts in VS Code or your favorite text editor. And if the file got corrupted, you were often out of luck.

With the new plain-text format introduced in R2025a, Live Scripts are now stored as .m files with Markdown-based markup in comments. Here's what that looks like:

The key benefits:
Git-friendly: You can now see exactly what changed between commits
Editor-agnostic: Open and edit in VS Code, Notepad++, or any text editor
AI-friendly: Large language models can generate and modify plain-text Live Scripts directly
This last point is what makes the agentic workflow possible. An AI agent can read your existing script, restructure it as a Live Script in plain text, and MATLAB opens it seamlessly in the Live Editor with full formatting.

The automated documentation workflow

Now let me walk you through the complete workflow. I'll be using Claude Code with the MATLAB MCP Core Server, but this works with any MCP-compatible client.

Step 1: Convert your script to a Live Script using skills

Here's the key insight: you don't need to write a Live Script from scratch. You can hand your existing analysis to an AI agent and ask it to transform it.

The matlab/skills repository contains curated skill templates for various MATLAB workflows. For generating properly formatted plain-text Live Scripts, point your AI assistant to the matlab-live-scripts skill.

The concept of Agent Skills introduced first by Anthropic in Claude enables "lazy-loading" of context in your agentic conversation (think Neo in The Matrix who "knows kung-fu" after getting a single file upload). We have shared a few MATLAB specific skills in github.com/matlab/skills.

Here's an example prompt you might use:

Using the matlab-live-script skill from github.com/matlab/skills,

convert my outage_analysis.m script into a plain-text Live Script.

Add section headings, narrative explanations of what each plot reveals,

and a summary of findings.

The AI reads your existing code, understands the analysis, and generates a .m file with the correct markup syntax—section headers using %[text] ## Title, explanatory text between code blocks, and the required appendix closure. Your analysis logic stays the same; it just gets wrapped in a professional narrative.

Step 2: Review the results in the Live Editor

After generating the Live Script, open it in MATLAB to verify everything looks right. The figures will be embedded inline with your code and narrative once you run the script. You'll see your outage histograms, scatter plots, and box charts rendered beautifully alongside the explanatory text that the AI generated.

This is also where you can make adjustments. Maybe you want to tweak a plot title, add a finding the AI missed, or reorganize a section. The plain-text format means any edits show up cleanly in version control.

Step 3: Export to Markdown

Now for the magic. MATLAB's export function (R2023b+) can convert your Live Script to Markdown:

export('outage_analysis.m', 'README.md', ...

 Format='markdown', ...

 EmbedImages=false, ...

 IncludeOutputs=true)

Setting EmbedImages=false creates a README_media/ folder with your figures as separate files—which is what you want for GitHub. The Markdown file references them with relative paths, and GitHub renders everything beautifully.

Step 4: Push to GitHub or GitLab

The final step is committing your work to version control. Whether you're a researcher sharing your publications or a student building your portfolio—GitHub is the natural choice. GitLab works just as well.

Your repository structure will look like this:

outage-analysis/

├── README.md ← Exported from Live Script

├── README_media/ ← Figures referenced by README

│ ├── figure_0.png

│ ├── figure_1.png

│ └── figure_2.png

├── outage_analysis.m ← Plain-text Live Script (source)

└── .gitattributes

Putting it all together

The complete workflow in one AI conversation might look like this:

Each step triggers the appropriate MCP tools, and your documentation stays perfectly in sync with your analysis. And here's the best part: when someone asks you to tweak a parameter—say, filter for outages after 2010 or focus on a single region—you just re-run the conversation and the entire repository updates: code, figures, narrative, and README.

Tips for best results

A few lessons learned from using this workflow:

Use the plain-text format (R2025a+): Set it as your default in Settings → MATLAB → Editor/Debugger → Live script format → M. This makes AI generation much more reliable.
Set .mlx as binary in .gitattributes if you're also tracking the binary format: *.mlx binary
Add an "Open in MATLAB Online" badge: Help others run your analysis instantly:
[![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)]
(https://matlab.mathworks.com/open/github/v1?repo=USERNAME/REPONAME)

Special thanks to Rohan Amarapurkar for contributing to this post and for his work making Live Scripts AI-friendly.

Building an Optimization Agent with MATLAB MCP Core Server

Yann Debray — Mon, 26 Jan 2026 20:00:26 +0000

Co-author: Tom Couture

Tom Couture is the Product Manager for Optimization. In this blog post, he joins me to demonstrates how to use the new MATLAB MCP Core Server to build optimization agents.

If you are like Tom, you have probably spent hours setting up optimization problems in MATLAB—defining objective functions, constraints, choosing solvers, tweaking options. Now, what if I told you that you can have a conversation with an AI agent that does all of this for you, like a mini Tom in your pocket, while actually running the optimization in your local MATLAB?

That is where the MATLAB MCP Core Server comes in, combined with the powerful Optimization Toolbox. In this post, we are going to walk you through how to create an optimization agent that can solve real engineering problems—from simple constrained optimization to computationally expensive CFD-based design optimization using surrogate models.

The First Thing Your Agent Should Do: Check the Toolboxes

One of the first features of the MATLAB MCP Core Server I demo is the detect_matlab_toolboxes tool. Before your agent starts writing optimization code, it should verify that you have the necessary toolboxes installed.

Here is a sample prompt to your AI assistant (Claude Desktop®, GitHub Copilot®, or any MCP-compatible client):

"Check which MATLAB toolboxes I have installed, specifically looking for Optimization Toolbox and Global Optimization Toolbox."

The agent will call the detect_matlab_toolboxes tool and return something like:

Optimization Toolbox - Version 25.2 (R2025b) ✓

Global Optimization Toolbox - Version 25.2 (R2025b) ✓

This is crucial because the solver you can use depends entirely on what you have licensed. No Optimization Toolbox? The agent will know to fall back to fminsearch. Have Global Optimization Toolbox? Great, surrogateopt is on the table for those expensive simulations.

Example 1: Structural Beam Design Optimization

Let me demo to you a classic engineering optimization problem: designing a cantilever beam for minimum weight while satisfying stress and deflection constraints.

The Problem

We want to minimize the weight of a rectangular cross-section beam subject to:

Maximum stress constraint (must not exceed yield strength)
Maximum deflection constraint (must not exceed allowable deflection)
Bounds on width and height

Here is the prompt I gave to Claude Code:

"I need to optimize a cantilever beam design. The beam has length L=5m, carries a tip load P=10kN, made of steel with E=200 GPa and yield stress=250 MPa. I want to minimize the cross-sectional area (width × height) while keeping tip deflection under 10mm and max stress under the yield stress. Width should be between 50-200mm, height between 100-500mm. Please set this up and solve it using MATLAB."

The agent generated and ran the following code:

% Beam optimization problem

L = 5; % Length [m]

P = 10000; % Tip load [N]

E = 200e9; % Young's modulus [Pa]

sigma_yield = 250e6; % Yield stress [Pa]

delta_max = 0.010; % Max deflection [m]

% Objective: minimize cross-sectional area

objective = @(x) x(1) * x(2); % width * height

% Nonlinear constraints

nonlcon = @(x) beamConstraints(x, L, P, E, sigma_yield, delta_max);

% Bounds: [width_min, height_min] to [width_max, height_max]

lb = [0.05, 0.10]; % [m]

ub = [0.20, 0.50]; % [m]

% Initial guess

x0 = [0.10, 0.25];

% Solve

options = optimoptions('fmincon', 'Display', 'iter', 'Algorithm', 'sqp');

[x_opt, fval, exitflag] = fmincon(objective, x0, [], [], [], [], lb, ub, nonlcon, options);

fprintf('Optimal width: %.1f mm\n', x_opt(1)*1000);

fprintf('Optimal height: %.1f mm\n', x_opt(2)*1000);

fprintf('Optimal area: %.2f cm²\n', fval*1e4);

The constraint function:

function [c, ceq] = beamConstraints(x, L, P, E, sigma_yield, delta_max)

 b = x(1); % width

 h = x(2); % height

 I = b * h^3 / 12; % Second moment of area

 sigma = P * L * (h/2) / I; % Max bending stress

 delta = P * L^3 / (3 * E * I); % Tip deflection

 c(1) = sigma - sigma_yield; % Stress constraint

 c(2) = delta - delta_max; % Deflection constraint

 ceq = [];

end

The result? An optimal beam with width 80.2mm and height 189.4mm—satisfying both constraints at the boundary, which is exactly what you would expect from a well-posed optimization problem.

You can take a look at my conversation with Claude to see some of the rationale as to why he used a fmincon solver for this problem:

https://mathworks.github.io/MATLAB-AI-Blog/optimization-agent/claude/

In the repo, I'm also sharing a "skill" for a problem-based approach:

https://github.com/mathworks/MATLAB-AI-Blog/blob/main/optimization-agent/.claude/skills/problem-based-optim/SKILL.md

Example 2: CFD-Based Optimization with Response Surfaces

Now let's get to the fun part. One of my favorite applications of optimization in MATLAB is when you have a computationally expensive simulation—like CFD—and you need to find optimal design parameters.

The Lid-Driven Cavity Problem

The lid-driven cavity is the "Hello World" of CFD. It is a square cavity where the top wall (the "lid") moves at a constant velocity, and you solve the Navier-Stokes equations to find the flow field. For this demo, I will be using an implementation from this problem in pure MATLAB from my colleague Michio in Japan. The code can be found on GitHub: 2D Lid-Driven Cavity Flow Solver

The question I posed to the agent:

"I have a CFD solver in the folder 2D-Lid-Driven-Cavity-Flow-Incompressible-Navier-Stokes-Solver. I want to
optimize the lid velocity and Reynolds number to minimize the maximum vorticity in the secondary corner vortex of
a lid-driven cavity flow. Reynolds number should be between 100 and 1000, and lid velocity between 0.5 and 2.0
m/s."

Why Surrogate Optimization?

If you have tried running fmincon on a CFD objective function, you know the pain. Each function evaluation takes 30 seconds, and gradient-based methods might need hundreds of evaluations. surrogateopt from the Global Optimization Toolbox is designed exactly for this scenario:

What's New	Why It Matters
Builds a surrogate (response surface) of your expensive function	Fewer actual CFD simulations needed
Uses Radial Basis Function interpolation	Accurately approximates complex surfaces
Global search capability	Doesn't get stuck in local minima
Supports parallel evaluation	Use all your CPU cores

Here is the code the agent generated:

% Define bounds

lb = [100, 0.5]; % [Re_min, V_min]

ub = [1000, 2.0]; % [Re_max, V_max]

% Set up surrogate optimization

options = optimoptions('surrogateopt', ...

'Display', 'iter', ...

'PlotFcn', 'surrogateoptplot', ...

'MaxFunctionEvaluations', 50, ...

'MinSurrogatePoints', 20);

% Run optimization

[x_opt, fval, exitflag, output] = surrogateopt(@cavityObjective, lb, ub, options);

fprintf('Optimal Reynolds number: %.0f\n', x_opt(1));

fprintf('Optimal lid velocity: %.2f m/s\n', x_opt(2));

fprintf('Minimum corner vorticity: %.4f\n', fval);

The objective function:

function obj = cavityObjective(x)

 Re = x(1);

 V_lid = x(2);

% Run CFD simulation (using 2D-Lid-Driven-Cavity solver)

 [u, v] = runCavitySimulation(Re, V_lid);

% Calculate vorticity in corner region

 [vorticity] = calculateVorticity(u, v);

% Extract max vorticity in secondary vortex region

 cornerRegion = vorticity(1:20, 1:20);

 obj = max(abs(cornerRegion(:)));

end

The beauty of surrogateopt is that it builds a response surface as it goes. After just 20 function evaluations (about 5 minutes), it found the optimal operating point—something that would have taken hours with a grid search.

What's Next?

The combination of MATLAB MCP Core Server + Optimization Toolbox opens up a whole new way of doing engineering optimization. Instead of context-switching between documentation, code editor, and command window, you can have a conversation with an AI that:

Checks your toolboxes to know what solvers are available
Formulates the problem based on your natural language description
Writes and runs the code in your local MATLAB
Iterates on errors without you copying and pasting

If you want to try this yourself, head over to the MATLAB MCP Core Server repository and follow the setup instructions. The server provides five core tools—but combined with the 100+ functions in Optimization Toolbox, the possibilities are endless.

Happy optimizing! 

Giving Local AI Agents the ability to use MATLAB with MCP

Yann Debray — Wed, 21 Jan 2026 15:26:20 +0000

Guest writer: Abhijit Bhattacharjee

Abhijit is an application engineer at MathWorks and an expert in AI. He supports customers with the latest and greatest technologies in the space, specifically Agentic AI in the past couple of months.

Building on my colleague Mike's fabulous article on running LLMs on the NVIDIA DGX Spark and connecting to them in MATLAB, I wanted to see if I could flip the workflow; instead of MATLAB calling an LLM (Large Language Model), what if I could have a local LLM agent call MATLAB? That way, the entire MATLAB itself becomes a tool at the agent's disposal, ready to perform, execute, and verify code that the LLM writes.

And the best part? Nothing leaves my network and it's all handled locally.

Fortunately for me, I was also able to get my hands on a beautiful NVIDIA DGX Spark unit to play around with.

You can learn more about the DGX Spark's specs HERE, but the key thing here is that it has enough VRAM (128GB) to handle local LLMs of significant enough size that they can do real engineering work. And that's what I'd like to share with you today.

Setting up the local LLM

Like Mike, I chose to use the fantastic gpt-oss-120b model for its reliable tool-calling abilities and its high performance as a mixture-of-experts (MoE), which means it only uses a fraction of 120 billion parameters actively, reducing the computational load. However, I chose a slightly more complex route than he did, and decided to compile llama.cpp from source to run the model, to try and eke out even more tokens-per-second (tps) than Ollama, which also uses llama.cpp as its backend. While this sounds intimidating, it's actually not so bad, especially with the comprehensive instructions in the repository.

To make use of the local model, you need to launch llama-server with the right parameters. Here is my optimized launch command for the DGX Spark to run gpt-oss-120b:

llama-server \

 -m models/gpt-oss-120b/Q4_K_M/gpt-oss-120b-Q4_K_M-00001-of-00002.gguf \

 --host 0.0.0.0 --port 8080 \

 -ngl 999 \

 -fa on \

 -t 10 \

 -c 0 \

 -b 2048 -ub 2048 \

 -ctk q8_0 -ctv q8_0 \

 --no-mmap \

 --jinja \

 --reasoning-format auto \

 --chat-template-kwargs "{\"reasoning_effort\": \"medium\"}" \

 --temp 1.0 \

 --top-p 1.0 \

 --top-k 0

Running it in this way allowed me to specify some optimizations, such as --no-mmap, which disables memory-mapped file I/O (not needed for unified memory architectures such as the DGX Spark) and -fa on, which enables flash attention kernels, speeding up processing of long sequences of tokens.

Agentic AI coding with the local model

Now before we get to using MATLAB as a callable tool, I needed a way to interact with this local model outside of MATLAB. Fortunately, we can use the very popular agentic AI terminal application OpenCode as a harness. OpenCode allows you to configure a local model in a number of ways. One easy way is to use the opencode.json configuration file.

The other thing I want to do is point OpenCode at the local MATLAB MCP Core Server instance on my machine. To catch up on Model Context Protocol (MCP) and how it works, definitely check out one of our recent blog posts on the topic, like THIS ONE.

A bit more JSON finagling, and our full opencode.json file to configure both the local LLM (with an endpoint address of 192.168.108.170) and the local MATLAB MCP connection looks as follows.

{

 "$schema": "https://opencode.ai/config.json",

 "provider": {

 "llama.cpp": {

 "npm": "@ai-sdk/openai-compatible",

 "name": "llama.cpp (abhijit-spark)",

 "options": {

 "baseURL": "http://192.168.108.170:8080/v1"

},

 "models": {

 "gpt-oss-120b-GGUF": {

 "name": "gpt-oss-120b"

}

}

}

},

 "mcp": {

 "MATLAB MCP": {

 "type": "local",

 "command": [

 "C:\\Users\\abhijit\\Local Content\\Apps\\matlab-mcp-core-server-win64.exe", 

 "--matlab-root=C:\\Program Files\\MATLAB\\R2025b"

],

 "enabled": true,

}

}

}

After configuring everything as above, when I launch OpenCode, I'm greeted with a screen showing me that both the local model is selected and available, and that the MATLAB MCP is connected and running:

Let's start vibe coding!

To show off how well this works with the MATLAB MCP Core Server enabled, I'm going to enter the following prompt, which will do some data analysis on a built-in dataset that comes installed with MATLAB:

Create a MATLAB script that loads carbig dataset and creates 3 plots showcasing how different car properties affect MPG. Use default positions for any figures you create. 

Train an ensemble regression model using this data to predict MPG from weight, horsepower, displacement, and acceleration. Show me the model statistics and diagnostic plots.

Use the MATLAB MCP to execute and test your code.

Now normally, with frontier models such as Claude Opus or GPT-5.2, you don't need to specify that the MCP needs to be invoked. Those LLMs will figure it out automatically. But for gpt-oss-120b, I decided it to give that extra bit of guidance, just so it wouldn't spin its wheels for too long. Here's a video demonstration of my coding session.

So that's the magic: a local LLM agent driving MATLAB like a pro, with everything running on your own hardware and none of your data drifting off into the cloud. The DGX Spark has more than enough muscle to make models like gpt-oss-120b genuinely useful, and once you plug it into the MATLAB MCP Core Server, the whole setup feels surprisingly natural, almost like MATLAB just became another tool in your AI's toolbox.

Is it perfect? Not yet. But it's already good, and with a little prompt tuning (or a beefier model like Devstral 2), it gets even better.

This workflow shows what's coming: real engineering work powered by local AI agents, fully private, fully under your control, and honestly...pretty fun to use.

Reinforcement Learning on Hardware, explained by Brian Douglas

Yann Debray — Tue, 13 Jan 2026 15:00:49 +0000

Co-author: Brian Douglas

Brian is a Technical Content Creator at MathWorks and control engineer with over 20 years of experience in the field, and a passion for sharing his knowledge with others. He creates and posts engaging videos, drawings, and short writings on various engineering topics. You can find his Tech Talks series on mathworks.com and YouTube.

You've probably seen impressive demos of reinforcement learning agents doing amazing things—balancing poles, playing games, controlling robots. But here's the thing: getting from "cool simulation" to "actually running on hardware" is where it gets tricky.

My colleague Brian Douglas just released a Tech Talk that tackles exactly this question. Not the specifics of RL algorithms (we have a whole series for that), but something that doesn't get nearly enough attention: which approach should you take to get a good policy running on your hardware?

I know that doesn't sound terribly exciting at first. But trust me—it matters a lot for hardware safety and how long you'll spend waiting for your policy to converge.

The setup

Brian demonstrates this with a Quanser® Qube-Servo 2 rotary pendulum, controlled by a policy running on a Raspberry Pi®, which is connected to a PC running MATLAB® and Simulink®. Three pieces of hardware working together—and how you use them depends entirely on your approach to training.

If you want to follow along with your own hardware, check out the GitHub example that covers the complete workflow from plant modeling to deployment.

The decision flowchart

Here is the complete decision tree that Brian covers in his video. Let's break it down, step by step:

Let me walk you through the key decision points:

1. Do you have existing data?

You can learn a policy offline from data collected by humans or another controller. This is great for bootstrapping—getting a decent starting point before you do any online training.

2. Where do you get additional data?

This is the big fork in the road: train directly on hardware (real environment) or train in simulation (modeled environment). Both have trade-offs. Brian covers the environment setup in detail in Part 2 of the RL series.

Training directly on hardware

 Where does inference happen vs. where does learning happen?

This one's subtle but important. You might have a low-power embedded processor (like a Raspberry Pi) and a more powerful PC or cloud server. You can mix and match:

Approach	Pros	Cons
Train & run on embedded	Self-contained, minimal latency	Embedded processor may be too weak for training
Train & run on remote PC	Faster learning	Susceptible to latency and connection issues
Train on PC, run on embedded	Best of both worlds	More complex setup

Brian goes with that third option—and honestly, it's often the sweet spot for real hardware applications.

The results? Well...

The first episodes are rough. Random commands, motor jittering, the pendulum occasionally banging into the power cord (which let's admit, isn't great for the hardware). After several hours and almost 1,500 episodes, the policy could balance the pendulum—but with noticeable wobble and plenty of room for improvement.

The takeaway: training on hardware is straightforward but time-consuming, potentially dangerous, and hard to cover all operating states your system might encounter in the real world.

Training in simulation

Here's where things get more practical. With a model of your environment, you can:
- Train faster than real-time
- Forget about hardware safety during exploration
- Easily test different initial conditions and scenarios

Brian trained against a simulated Qube model for about 1,200 episodes. The result? A policy that controls the pendulum rock-steady in simulation—reward over 800, nice and settled.

But the real question: does it work on actual hardware?

For a detailed answer with code, see this example from the documentation: Train Reinforcement Learning Agents to Control Quanser QUBE Pendulum

The sim2real gap

When Brian deployed the simulation-trained policy to the real Qube, it worked pretty well! No terrible jittering, no banging into cables. But if you look closely, there's a small amount of wobble that wasn't there in simulation.

That's the sim2real gap—the difference between what your model predicts and what happens in reality. Now, this isn't necessarily a problem. Models don't have to be perfect; they just have to be useful. If the behavior meets your requirements, you're done.

But if it's not good enough, you have options:

1. Improve the model — Add more dynamics, use domain randomization to make your policy more robust

2. Fine-tune on hardware — Start from your simulation-trained policy and continue learning on the real system

That second approach is particularly nice because you're not starting from scratch. Your policy already knows roughly what to do, so training is faster and puts less stress on the hardware.

Why this matters

There's no single best way to learn a policy for hardware. It depends on how well you can model your environment, how hard it is to reset between episodes, and how much you care about hardware safety (spoiler: probably a lot).

But this workflow—train in simulation, fine-tune on hardware, run policy on embedded processor, learn on a remote computer—is actually ideal for many situations. It's also the foundation for continuous learning, where your policy keeps adapting as components wear out or conditions change, without requiring a full retraining cycle.

Brian goes into much more detail in the video, including live demos of all three approaches and the actual Simulink models involved. Highly recommend watching the full thing:

 Reinforcement Learning on Hardware

And if you're new to reinforcement learning, check out Brian's multi-part Tech Talk series that covers the fundamentals.

Happy reinforcement learning! 

Antigravity + MATLAB is wicked good

Yann Debray — Wed, 24 Dec 2025 16:30:42 +0000

Google released a new agentic development environment called Antigravity. And it works great with MATLAB. (It's wicked as they say in Boston!)

If you are looking to defy gravity, here is a fun use case for an app leveraging the power of MATLAB and Antigravity:

This article will look at three different components, that were built using Antigravity + MATLAB:

Component	Description
uihtml + React workflow	Modern web frameworks embedded seamlessly in MATLAB desktop apps
Flight data replay	Post-process and visualize trajectories with gravityFlightDashboard
Defying Gravity Toolbox	A fully-packaged MATLAB app with 3D graphics powered by Three.js

The AI Copy & Paste Problem (Revisited for apps)

Regular readers will remember the core problem that led us to release the MATLAB MCP Core Server: the tedious copy-paste loop between your favorite AI chat and MATLAB. Write code in ChatGPT or Claude, copy it, paste it in MATLAB, get an error, copy the error, paste it back... iterate.

The MCP server solved that for MATLAB code. But what about apps?

Building a MATLAB app with modern 3D graphics used to require deep knowledge of app building in MATLAB, plus OpenGL graphics. Now, with uihtml, you can embed any web technology—React, Three.js, D3.js—directly inside a MATLAB figure. The catch? You need to know web development too.

That is where AI agents come in. I described what I wanted in natural language, and Antigravity (with the MATLAB MCP Core Server connected) helped me scaffold the whole thing.

Connect MATLAB to Antigravity

Let's start by connecting MATLAB to Antigravity. There are two steps you can take, quite similar to how you would in VSCode (Antigravity is a fork of VSCode):

Install the MATLAB extension
Set up the MATLAB MCP Core Server

Navigate to the extension side-panel, and search for MATLAB:

You will find the MCP Server setup screen in the three dots on the top right of the Agent side panel (slightly different from VSCode).

Once your MATLAB is connected to Antigravity, you can ask the following prompt:

Generate a MATLAB App with 2 windows: One web frontend implementing a flight simulator in React and ThreeJS that enables to record the trajectory in a CSV file. This web frontend will be integrated in a MATLAB uihtml component. The second window is a dashboard post-processing the trajectories with MATLAB plots. There is a button that enables to open the simulator from this view.

Testing web frontend before integration in uihtml

MATLAB Apps can integrate HTML UI components through the use of the function uihtml. One great combo is to use the embedded chrome browser in Antigravity to test the interactions of the web frontend before integrating it into your app:

Let's Walk Through the Generated Code

The Main App Entry Point

The core of gravityFlightSimulator.m is surprisingly simple:

function gravityFlightSimulator()

% Create main figure with appropriate size

 fig = uifigure('Name', 'Defying Gravity', ...

'Position', [100 100 1200 800], ...

'Color', [0 0 0], ...

'AutoResizeChildren', 'off');

% Get the path to the HTML file and icon

 appDir = fileparts(mfilename('fullpath'));

 htmlFile = fullfile(appDir, 'dist', 'index.html');

 iconFile = fullfile(appDir, 'dist', 'broom.png');

% Set the app icon (yes, it's a broom)

 fig.Icon = iconFile;

% Create uihtml component filling the entire figure

 h = uihtml(fig, 'Position', [0 0 fig.Position(3) fig.Position(4)]);

 h.HTMLSource = htmlFile;

% Handle figure resize to keep uihtml fullscreen

 fig.SizeChangedFcn = @(src, ~) resizeHTML(src, h);

end

That's it. About 20 lines of MATLAB to embed a full 3D flight simulator.

The Flight Controls

The web app (built with React and Three.js) provides the flight physics:

Control	Action
W/S	Throttle Up/Down
Up/Down	Pitch Up/Down
Left/Right	Roll Left/Right

And you can switch between a plane and a witch on a broomstick (hence the icon). Because why not?

Post-Processing with gravityFlightDashboard

The app can export flight data to CSV. Then comes the MATLAB part—analyzing trajectories with gravityFlightDashboard:

gravityFlightDashboard('gravity-flight-2025-12-07.csv')

This opens a replay dashboard with:

3D trajectory visualization with heading arrows
Altitude vs. time plot
Play/Pause/Reset controls with a timeline slider
Real-time flight metrics: speed, altitude, pitch, roll

% The dashboard using MATLAB graphics

plot3(pathAxes, position(:,1), position(:,2), position(:,3), ...

'Color', [0.7 0.7 0.7], 'LineWidth', 1.25);

craftMarker = plot3(pathAxes, position(1,1), position(1,2), position(1,3), ...

'o', 'MarkerFaceColor', [0.95 0.3 0.2], 'MarkerEdgeColor', 'k', ...

'MarkerSize', 8);

This is the beauty of the hybrid approach: use web tech for the interactive 3D simulation, use MATLAB for post-processing and analysis.

If you are interested in more advanced flight data analysis, I recommend you take a look at our UAV toolbox.

Packaging as a Toolbox

One of my favorite parts: you can package this as a proper MATLAB toolbox (.mltbx file) that anyone can install with one click.

The "Gravity" toolbox appears right alongside your other add-ons.

Install it like this:

matlab.addons.install('Gravity.mltbx')

Then just run:

gravityApp

The toolbox bundles everything: the MATLAB code, the web assets, the broom icon. Users don't need to know anything about React or Three.js—they just install and fly.

Calling the Wizard of Apps

For the next post of this series on Agentic App Building, I will turn to colleague Pax, who I call the "Wizard of Apps":

Next episode: Rick Paxson aka "Pax"

Rick Paxson is the Director of Computational Biology at MathWorks. He is an experienced programmer and an early adopter of AI assisted coding. I always turned to him for advices on how to best leverage AI in software development.

He developed some particular "skills" that he shared with Ned and I to build MATLAB Apps with a web front end. If you are too impatient, you can get a sneak peek into the recipe we will use: skills/skills/matlab-uihtml-app-builder/SKILL.md

In the meantime, I wish you a wicked Christmas

PS: Check out the code and have fun defying gravity

MATLAB-AI-Blog/antigravity-plus-matlab-is-wicked-good at main · mathworks/MATLAB-AI-Blog

Winning a Predictive Maintenance Data Challenge with Engineering Expertise

Yann Debray — Tue, 16 Dec 2025 15:42:47 +0000

Co-author: Peeyush Pankaj

Peeyush Pankaj is an application engineer at MathWorks with a strong Aerospace background and deep domain expertise in vibrations and mechanical systems (engine lubrication circuit design & analysis). In this blog post, he tells us about his experience at the 2025 Prognostics and Health Management Society Conference Data Challenge.

For the last several years, MathWorks has attended the Prognostics and Health Management (PHM) Society Conference – a global conference focused on predictive maintenance applications. This year, the team participated in the 2025 PHM Data Challenge – and took home first place. The MathWorks team comprised Peeyush Pankaj, Reece Teramoto, Shyam Joshi, Xiaomeng Peng, and Taylor Hearn.

Shyam Joshi and Reece Teramoto present the team's winning solution at the PHM Society Conference 2025 in Bellevue, WA.

A Real-World Data Challenge

The 2025 PHM Data Challenge asked participants to predict when two components of a commercial jet engine would need maintenance. Using sensor data from four engines across thousands of flights, teams had to create models to estimate how many flights remained before three different maintenance events: High Pressure Turbine (HPT) shop visit, High Pressure Compressor (HPC) shop visit, and HPC water wash. The three maintenance predictions made this a more complex problem than previous PHM data challenges. The dataset was intentionally realistic and messy, with missing sensors, noise, and flights out of order. And predictions that came too late were penalized more heavily. The teams faced a big challenge to generalize well and avoid overfitting the data. This was no simple toy example.

Engineering Expertise + MATLAB = Win

This year, MathWorks had two advantages in the data challenge: deep engineering domain expertise and a knowledge of AI and Predictive Maintenance tools in MATLAB. The team was led by Peeyush Pankaj, co-author of this post, whose prior career in aerospace engineering helped him lead the team to interpret degradation patterns, identify practical domain-specific features, and understand realistic engine behavior. Next, Peeyush describes how MathWorks did it.

The Solution

Read the full Paper: Maintenance Service Events Prediction Modeling of Aircraft Gas Turbine Engines | Annual Conference of the PHM Society

What made this year’s PHM Society Data Challenge particularly interesting was how closely it resembled the messiness of real engine prognostics. We were given only four engines for training, each with multiple failure-linked events that interact with one another the same way they do on a real fleet. The test engines operated in envelopes not seen in training, several sensors were entirely missing, and the individual flight files were shuffled out of sequence. This is very typical of fielded assets: a model must learn from whatever limited history is available and still generalize to engines of the same make and model that operate differently, age differently, and undergo maintenance at different intervals. The challenge captured that reality extremely well.

The approach used by the MathWorks team

To handle the missing sensing channels in the test and validation sets, we built virtual sensor models to reconstruct key pressures and temperatures. Once the physical variable set was complete, we introduced domain-informed features such as compressor efficiency drop, turbine temperature gradient change, pressure ratio decay across the engine core, and several thermodynamic health markers that typically reflect aging. In addition, the raw dataset consisted of up to eight snapshots per cycle, sometimes fewer, so we converted everything into cycle-level statistics. This preserved the underlying physics and made it possible to analyze degradation on a cycle-by-cycle basis rather than dealing with snapshot irregularities.

A major breakthrough came when we built global health indicators using the Health Indicator Designer app in Predictive Maintenance Toolbox. When plotted, the HPC health indicator showed clear upward recoveries after Water Wash events, confirming exactly what we see in real field operations: regular washing restores compressor health and extends the life of downstream modules. That insight influenced the modeling strategy. We used neural networks for HPT shop visit predictions, and for HPC and Water Wash predictions we used sequence-to-sequence LSTM models with custom loss functions that penalized incorrect predictions more severely when the maintenance event was near. This helped prevent late forecasts for safety-critical events. MATLAB’s Deep Network Designer and Experiment Manager were extremely helpful here, allowing us to iterate quickly through model architectures and training strategies without writing everything from scratch.

Using Health Indicator Designer to design custom health indicators for HPC and HPT.

Since the challenge deliberately scrambled the order of flight files in the test set, we finally introduced a profile-based registration method that aligns the files chronologically by matching the shape of the predicted health indicators. This step ensured that the degradation sequence remained physically consistent, which improved our confidence in the predictions.

Remaining Useful Life features such as event flags and post-event Health Indicator recovery metrics.

Overall, combining aircraft engine domain knowledge with productivity tools in MATLAB allowed us to move rapidly from noisy, inconsistent raw data to a complete, physics-aligned prognostics pipeline, ultimately resulting in first place in this year’s competition.

Congratulations to all the participants in the challenge and we hope to see you next year!

MATLAB MCP Core Server Update: Bringing Your Coding Guidelines Directly to AI

Yann Debray — Thu, 11 Dec 2025 13:37:18 +0000

Last month, we announced the release of the MATLAB Model Context Protocol (MCP) Core Server, opening a new bridge between MATLAB and the next generation of AI agents. The response has been incredible, and we’ve been listening closely to how you are using these agents to accelerate your workflows. Today, we are excited to share a new feature-driven update to the server (v0.3), which goes beyond just executing code. This release introduces a fundamental shift in how your AI assistant understands your development environment: MCP Resources.

Beyond Tools: The Power of Context

In our initial release, we focused on Tools—giving the AI the ability to run MATLAB code, evaluate expressions, and retrieve documentation. That’s the "hands" of the agent. With today’s update, we are giving the agent "eyes." The Model Context Protocol isn't just about execution; it’s about Context. By adding support for Resources, the MATLAB MCP server can now feed structured read-only data directly into the Large Language Model’s (LLM) context window. This ensures the model knows how you want your code written before it writes a single line.

Feature Highlight: Standardizing Code with "MATLAB Coding Guidelines"

We know that generating code is easy, but generating compliant, production-ready code is hard. To demonstrate the power of Resources, we have connected the MATLAB MCP server directly to the MATLAB AI Coding Rules. Now, instead of prompting your agent with "Write this script and please remember to use camelCase and don't use i for loops," you can simply attach the Coding Guidelines Resource.

A Real-World Workflow: Imagine you are asking an AI agent (like Claude Desktop or Cursor) to write a script that processes complex number arrays.

Without Context: The model might generate a loop using i as an iterator:

% Typical AI Output
for i = 1:100
    y = x + 3i; % Potentially ambiguous or error-prone if 'i' is overwritten
end

With the MATLAB Coding Guidelines Resource: You simply select the matlab://resources/coding_guidelines resource in your MCP client. The agent instantly reads the guidelines, specifically the rule regarding imaginary units and variable naming. The Result: The agent auto-corrects its behavior based on the guideline recommendation to "Use 1i or 1j for imaginary numbers" and avoids using i as a loop variable to prevent shadowing.

% Output with MCP Resource attached
for k = 1:100
    y = x + 3*1i; % Adheres to MathWorks guidelines for imaginary units
end

This ensures your AI-generated code isn't just functional—it’s clean, maintainable, and adheres to the standards used by large engineering teams.

What Else is New?

This release includes several other improvements driven by community feedback:

Lazy Loading: We are optimizing the server startup. MATLAB will now "lazy load," meaning the server starts instantly and only launches the full MATLAB engine when you make your first tool call.
System Tests: We've added a robust suite of system tests to ensure stability across different OS environments.
Watchdog Logging: Improved debugging with dedicated logs for the server watchdog process.

Try It Out

The updated MATLAB MCP Core Server is available now.

Update your server: Get the latest release from our GitHub Repository.
Explore the Guidelines: Check out the source of inspiration for our new resource at the MATLAB Coding Guidelines repo.
Connect: Point your AI chat or agent (like Claude or IDEs supporting MCP) to the new server and look for the new Resources (in Claude Desktop, it is available with the + icon).

We can’t wait to see what you build—and how cleanly you code it!

MATLAB MCP Client is out on GitHub now!

Yann Debray — Wed, 10 Dec 2025 14:22:17 +0000

Guest Writer: Shweta Pujari

Shweta Pujari is the Product Manager for AI and GenAI. In this blog post, she joins me to demonstrate how to use the new MATLAB MCP Client to build agentic workflows in the MATLAB language.

MathWorks has released a new capability on GitHub – the MATLAB MCP Client – enabling users to easily connect MATLAB-based AI workflows to external services and third-party tools (via HTTP).

https://github.com/matlab-deep-learning/mcpHTTPClient

Note: About a month earlier, MathWorks also released the MATLAB MCP Core Server on GitHub, which provides a reference MCP implementation for calling MATLAB from third party AI chats and agents.

In this post, we’ll break down what the MCP client is, how it works, and why it’s a big deal for engineers building AI solutions in MATLAB.

What is the MATLAB MCP Client?

Model Context Protocol (MCP) is an emerging standard that defines how AI models communicate with external tools and services. Think of MCP as a language that both an AI model and a tool server understand – it covers how to list what tools are available and how to invoke those tools with specific inputs, getting back results in a structured way. Many advanced LLM applications today use agents that can call external functions (for example, an AI assistant that calls a weather API or database query). MCP provides a formal framework for this kind of tool calling so that any AI client can talk to any tool server that speaks MCP.

With this capability, you can implement an MCP client entirely in MATLAB code. In practical terms, this add-on allows MATLAB to connect to an MCP-compatible server over HTTP and use the tools that server offers. Once connected, MATLAB can list the available tools on that server and then call those tools on demand. Importantly, this integration is designed to work hand-in-hand with the Large Language Models (LLMs) with MATLAB add-on, enabling the language model to automatically decide when to use these tools as needed.

Key capabilities of the MATLAB MCP Client

Connecting to Tools via MCP Servers: You can create an MCP client in MATLAB that connects to any streamable HTTP MCP server by specifying its URL (endpoint). Upon connection, the client automatically fetches the list of available tools from the server. This means MATLAB instantly knows what functions the server can perform (e.g., “get_weather”, “run_simulation”, “query_database”, etc.), along with details about each tool’s inputs and outputs.
Calling External Tools: With the MCP client, calling an external tool becomes as straightforward as calling a local MATLAB function. The add-on provides a high-level function callTool for this purpose. You simply pass in the tool name and required parameters, and callTool handles the communication with the server, returning the result to MATLAB. There’s no need to manually craft HTTP requests or parse JSON – the client does that behind the scenes. This dramatically simplifies integration with external APIs or services.
Integrating with LLM Workflows: Perhaps the most exciting capability is enabling “agentic” AI workflows. By combining this MCP client with the LLMs with MATLAB add-on, you allow a large language model in MATLAB to autonomously decide when to call an external tool to fulfill a user’s request. The MCP client exposes the server’s tools to the LLM: you convert the list of tools into a form the model understands (openAIFunction objects for OpenAI’s function-calling interface) and pass them into your LLM session. Then, when you prompt the LLM, it can choose to output a tool call (including the tool name and arguments) if it determines that using a tool is the best way to get the answer. MATLAB captures this intended function call, and you can execute it via callTool(client, toolRequest) to get the result. In short, the MCP client makes it possible for an AI assistant in MATLAB to not just talk about external data or actions, but to actually perform those actions by invoking real services.

Get started with the MATLAB MCP client

This example demonstrates how to easily build an MCP Client in MATLAB to connect with an MCP server and use an LLM to call the server tools. It uses a single tool from a prime sequence MCP server.

Set-up the interface to call OpenAI LLMs

Make sure you get the latest version of the LLM-with-MATLAB repo:

Create a .env file with your OPENAI_API_KEY

OPENAI_API_KEY=sk-proj-xxxxx

gitclone("https://github.com/matlab-deep-learning/llms-with-matlab")
addpath("llms-with-matlab")
loadenv '.env'

Build the MCP client

Here is how you can connect to the MCP server endpoint from MATLAB:

endpoint = "https://production-server-demo.mathworks-workshop.com/primeSequence/mcp";
client = mcpHTTPClient(endpoint)

client = 
  mcpHTTPClient with properties:

       Endpoint: "https://production-server-demo.mathworks-workshop.com/primeSequence/mcp"
    ServerTools: {[1×1 struct]}

The first step is to discover the tools made available by the MCP server. You can loop to list them all. Here there is only one:

serverTools = client.ServerTools;
for i = 1:length(serverTools)
    disp(serverTools{i}.name)
    disp(serverTools{i}.description)
    disp('---')
end

 
primeSequence
Return the first N primes of the given sequence type. Four sequence types supported: Eisenstein, Balanced, Isolated and Gaussian.
---

Next step is to look up the arguments required to call a tool.

tool1 = serverTools{1};
toolName = tool1.name;
client.ServerTools{1}.inputSchema

The input schema informs which arguments or properties are required:

client.ServerTools{1}.inputSchema.properties

ans = struct with fields:
       n: [1×1 struct]
    type: [1×1 struct]

client.ServerTools{1}.inputSchema.properties.n

ans = struct with fields:
           type: 'number'
    description: 'Length of the generated sequence'

client.ServerTools{1}.inputSchema.properties.type

ans = struct with fields:
           type: 'string'
    description: 'Name of the sequence to generate'

client.ServerTools{1}.inputSchema.required

ans = 2×1 cell array
'n'       
'type'

Integrate the MCP client to the model

The following functions are provided by the LLMs with MATLAB repo. In this example, the OpenAI service is used to provide the Large Language Model.

f = openAIFunction(serverTools)

f = 
  openAIFunction with properties:

    FunctionName: "primeSequence"
     Description: "Return the first N primes of the given sequence type. Four sequence types supported: Eisenstein, Balanced, Isolated and Gaussian."
      Parameters: [1×1 struct]

model = openAIChat(Model="gpt-5-mini",Tools=f)

model = 
  openAIChat with properties:

           ModelName: "gpt-5-mini"
         Temperature: 1
                TopP: 1
       StopSequences: [0×0 string]
             TimeOut: 10
        SystemPrompt: []
      ResponseFormat: "text"
     PresencePenalty: 0
    FrequencyPenalty: 0
       FunctionNames: "primeSequence"

Let the model select which tool to call. Here there is only one tool to choose from:

[~,completeOutput] = generate(model,"generate a sequence of 10 prime numbers")

completeOutput = struct with fields:
           role: 'assistant'
        content: []
     tool_calls: [1×1 struct]
        refusal: []
    annotations: []

completeOutput.tool_calls

ans = struct with fields:
          id: 'call_5TOPVJ5zftW3WWydHQ0fmpyR'
        type: 'function'
    function: [1×1 struct]

Now just integrate this logic in an agentic loop:

toolRequest = completeOutput.tool_calls(1).function

toolRequest = struct with fields:
         name: 'primeSequence'
    arguments: '{"n":10,"type":"Eisenstein"}'

output = callTool(client,toolRequest)

output = "[2,5,11,17,23,29,41,47,53,59]"

If you want to see this workflow in action, watch this video to see how you can create an MCP client in MATLAB and use LLMs to call tools from the connected MCP server.

This code can be found here: https://github.com/mathworks/MATLAB-AI-Blog/tree/main/matlab-mcp-client-on-github

Let us know what you will build with this!

Artificial Intelligence

Less Typing, More Creating: MATLAB Copilot Comes to Your Android Phone

Why an AI Assistant on Your Phone Changes Things

Copilot Chat

Explain Code

When Will You Use This?

How to Get Started

Try It Out

Advanced Battery State of Charge Estimation with AI

Data Preparation

AI Modeling

Real-Time Simulation

Compression

Deployment

Conclusion

Automate the Documentation of Your MATLAB Analysis with Agentic AI

The documentation problem

Starting point: your existing analysis

Why plain-text Live Scripts change the game

The automated documentation workflow

Step 1: Convert your script to a Live Script using skills

Step 2: Review the results in the Live Editor

Step 3: Export to Markdown

Step 4: Push to GitHub or GitLab

Putting it all together

Tips for best results

Building an Optimization Agent with MATLAB MCP Core Server

The First Thing Your Agent Should Do: Check the Toolboxes

Example 1: Structural Beam Design Optimization

The Problem

Example 2: CFD-Based Optimization with Response Surfaces

The Lid-Driven Cavity Problem

Why Surrogate Optimization?

What's Next?

See Also

Giving Local AI Agents the ability to use MATLAB with MCP

Setting up the local LLM

Agentic AI coding with the local model

Let's start vibe coding!

Reinforcement Learning on Hardware, explained by Brian Douglas

The setup

The decision flowchart

Training directly on hardware

Training in simulation

The sim2real gap

Why this matters

Antigravity + MATLAB is wicked good

The AI Copy & Paste Problem (Revisited for apps)

Connect MATLAB to Antigravity

Testing web frontend before integration in uihtml

Let's Walk Through the Generated Code

The Main App Entry Point

The Flight Controls

Post-Processing with gravityFlightDashboard

Packaging as a Toolbox

Calling the Wizard of Apps