Shadowing Practice: WWDC26: Run local agentic AI on the Mac using MLX | Apple - Learn English Speaking with Video

בחר מצב תרגול

כל מצב פותח חדר תרגול במסך מלא.

144 משפטים

אם המשפטים קצרים או ארוכים מדי, לחץ על ערוך כדי להתאים אותם.

Hi, I'm Angelos, an engineer on the MLX team.

Today I'm going to show you how to build and run agentic AI workflows entirely on your Mac using MLX.

No cloud, no API keys, just your hardware doing the work.

Over the past year, AI agents have gone from research prototypes to everyday productivity tools.

But before we talk about agents, let's look at what we had before.

Here's the chat experience you're familiar with.

You send a prompt to the language model.

The model sends a response back.

If you need to act on that response, run a command, check a file, or fix an error, that's on you.

But now you're talking to an agent.

The agent talks to the model to decide what to do.

Then it calls tools to actually do it: running commands, reading files, hitting APIs — It observes the results and goes back to the model to figure out the next step.

User to agent.

Agent to model.

Agent to tools.

This is the agentic loop.

And it keeps cycling until your task is done.

What makes this particularly exciting on Apple silicon is that the entire loop can run locally.

Your data stays on your machine; AI is available anywhere at any time and there are no usage costs.

Let me now show you what this looks like in practice.

Here I have an agent running locally on my Mac.

On my screen you can see the setup: on the left, MLX running the model, and on the right the OpenCode agent I am interacting with.

I asked it to fetch the recent pull requests from our MLX repository, summarize the changes, and identify anything that needs my attention.

The model reasons about the request, calls the GitHub CLI to fetch PR data, reads through the diffs, and produces a concise summary.

All of this is happening locally, the model runs on my hardware and only the git commands reach the network.

Well it seems like I have a lot of work to do after finishing this video.

Now that you've seen what's possible, let me walk you through how we'll get there today.

We'll start by introducing the local agentic AI stack, the four layers that make all of this work, from MLX at the foundation all the way up to the agent.

Then I'll show you step-by-step how to set up your own local agent.

After that, we'll look at how MLX gets the most out of your hardware to make agents fast.

And finally, we'll go through more live demos, including building a SwiftUI app from scratch and fixing a bug in Xcode.

Let's start with the stack.

The stack that powers local agentic AI on the Mac has four layers.

Let me walk you through each one, starting from the bottom.

At the bottom is MLX, our open-source array framework purpose-built for Apple silicon.

It handles all the low-level computation, Metal acceleration, and memory management.

This is the foundation everything else is built on.

One level up, we have the language model layer.

MLX-LM provides everything you need to load, run, quantize, and fine-tune large language models.

It supports thousands of models from HuggingFace and gives you both CLI tools and a Python API.

If you saw our sessions last year, this is what we covered in depth.

But to serve an agent, we need something more: a persistent server with a standard API.

That's where MLX-LM Server comes in.

This is an OpenAI-compatible HTTP server that exposes your local model through a standard API.

It supports structured tool calling so the model can invoke functions reliably, and reasoning models that can analyze complex problems step-by-step before responding.

It's a drop-in replacement for any cloud LLM API.

And at the top of the stack, we have the agent itself.

This can be any framework or tool that speaks the OpenAI chat completions protocol: Xcode, OpenCode, Pi agent, a custom script, or anything else.

Because MLX-LM Server provides a standard interface, any agent framework works out of the box.

And it's not just us building on this stack.

Several popular apps and tools build on MLX and MLX-LM.

Ollama, LM Studio, and vLLM are just a few of the most popular ones.

The ecosystem is broad and growing, and if you're using one of these tools, chances are you're already running on MLX.

So that's the stack.

Let me now show you how to set everything up yourself.

It only takes three steps to go from zero to a fully local agentic workflow.

Step one: install MLX-LM.

A single pip install gets you everything you need.

Step two: start the server.

Run mlx_lm.server with a model that supports tool calling.

Starting with a small model to test your set-up is always a good idea.

The server starts up, loads the model, and is ready to accept requests on local host.

Step three: point your agent at the local server.

In most agent frameworks, you just set the base URL to your local server's address and you're done.

The agent doesn't know or care that the model is running on your Mac rather than in the cloud.

Let me show you a concrete example.

Here's the configuration for OpenCode.

We define a local provider.

In particular, we set the URL to local host and set the model name the server expects.

We also tell OpenCode to use this local model for everything.

That's it. Now every interaction runs through your local model.

Now that we have an agent talking to MLX, let's look at how MLX gets the most out of your hardware and addresses the key challenges of running agents locally.

The first challenge is prompt processing.

In an agentic workflow, every time the model receives tool output, it has to process all that new context before it can reason about the next step.

This happens over and over throughout the agentic loop, and it adds up fast.

Agentic sessions usually comprise hundreds of thousands of tokens and most of those are not generated.

The M5 chip introduces dedicated Neural Accelerators, and MLX can target them for exactly this kind of work.

Specifically, Neural Accelerators make matrix multiplication four times faster on M5 compared to M4.

And with the specialized multiplication and attention kernels in MLX this translates almost exactly to prompt processing speedup.

Reducing prompt processing time means your agents can read your codebase or process tool results almost four times faster.

And the best part?

Taking advantage of Neural Accelerators requires no special arguments or code changes on your part, MLX selects the best kernel for the available hardware and it just works.

Let's now talk about the second challenge, concurrency.

In practice, agents rarely work alone.

A common pattern is for an agent to spawn several subagents, each tackling a different part of the problem in parallel.

One might be reading documentation, another searching code, and a third writing tests; all at the same time.

That means multiple requests hitting your local model simultaneously.

MLX-LM Server handles this with continuous batching.

Instead of processing requests one at a time, it dynamically groups incoming requests into batches and processes them together on the GPU.

New requests can join a batch in progress without waiting for the current one to finish.

The result is that your subagents don't stall waiting in a queue.

They all get served concurrently, which keeps the entire agentic workflow moving.

Finally, the third challenge is model size.

Sometimes a single machine, even one with 512GB of RAM, just isn't enough because the model is too large to fit in memory.

The most recent DeepSeek model for instance has a whopping 1.6 trillion parameters and requires more than 800GB of memory just for the weights.

MLX's distributed support lets you spread a model across multiple Macs connected over Thunderbolt or Ethernet.

For agents, this is powerful in two ways.

First, it lets you run much larger, more capable models that wouldn't fit on a single machine.

Second, it parallelizes prompt processing across devices, which directly speeds up the agentic loop since the model can process tool results faster.

100

Setting up distributed inference with MLX-LM Server is fairly straightforward.

101

You launch the server using mlx.launch and a hostfile that contains information about the nodes and the type of connection.

102

The model is automatically sharded across all available devices and everything else just works.

103

Starting with macOS 26.2, we have support for Thunderbolt RDMA, which provides low-latency, high-bandwidth communication over Thunderbolt.

104

As a result, distributed inference with MLX has seen significant speed-ups: up to three times with four nodes.

105

To learn how to set up your Macs for distributed inference with MLX, check out our session "Explore distributed inference and training with MLX".

106

Remember our PR summary demo from earlier?

107

That was a simple read-and-report task.

108

Let's now push things further and see what happens when we ask an agent to write an entire project from scratch and then fix a bug in an existing one.

109

In this demo, I'm going to ask the agent to build a small SwiftUI application from scratch.

110

I have started with a blank Xcode project and I am asking the agent to build a drawing app for the iPad.

111

And off it goes.

112

The agent first looks at the current directory to find out the existing project structure, makes a plan to guide its implementation, and gets on to writing the code.

113

Using an agent means we don't need to copy anything or even build the project.

114

The agent writes the file then builds the app, fixing any errors it encounters along the way.

115

And here we are: the model is done, it only took a couple of minutes to create the first version of the app.

116

At the same time, I have the project open in Xcode and I am launching the app in the simulator.

117

Let's have a look at what the agent created.

118

It seems that we have a fully functional drawing app.

119

That's really nice for something that was built in 2 minutes.

120

With agentic coding, however, we can keep iterating until we are happy with the result.

121

For instance, I prefer rounded end caps.

122

I think they look much better.

123

Let's ask the agent to add them.

124

The agent will edit the code and recompile the app until it compiles without errors.

125

Let's test the new version.

126

We now have rounded end caps.

127

This is cool indeed.

128

It is even more cool that all of this happened locally, the model ran through MLX-LM server on this Mac and the agent used standard development tools like xcodebuild to verify and build its work.

129

For our final demo, let's look at something that integrates directly with your development environment.

130

Here I have the same drawing app project open in Xcode.

131

Let's connect Xcode to our already running MLX server.

132

We open the settings and navigate to the Intelligence tab.

133

We click on Add Chat Provider... and select a Locally Hosted provider.

134

We set the Port to 8080 or whichever port we selected when launching our MLX server and we're done.

135

Now Xcode can talk to our local model.

136

I have introduced a bug to our previously working app and now we can ask the model to fix it.

137

Within seconds, it identifies the bug and inspects the code around it.

138

Finally, it writes a fix and we can now build and run our app.

139

This shows how a locally running agent can integrate with your existing development workflow in Xcode, reading project files, understanding build errors, and making targeted fixes.

140

Local AI means your code never leaves your Mac.

141

Today, we showed you the full stack for running agentic AI locally on your Mac, from MLX all the way up to the agent, and how Neural Accelerators, continuous batching, and distributed inference make it fast.

142

To get started, install MLX-LM, launch the server, and point your favorite agent at it.

143

Everything we showed today is open-source and available right now.

144

Thank you for watching and I'm excited to see what you build with local agentic AI on the Mac.

הורד אפליקציה

כל מה שאתה צריך כדי לדבר בשטף

הגיית AIציון לכל משפט

תרגול IPAשלוט בכל צליל

אוצר מיליםבנה את מאגר המילים שלך

משחק אוצר מיליםלמד תוך כדי משחק

סרוק QR

Download on theApp Store Get it onGoogle Play

אותו ערוץ

WWDC26: Modernize your UIKit app | Apple

Business EnglishUniversity StudentsWorking Adults

FOR YOU

המלץ על סרטון

222 משפטים

אוצר מילים והערות הגייה לשיעור הזה

שיעור הדיבור הזה ברמה C1 מבוסס על הסרטון “WWDC26: Run local agentic AI on the Mac using MLX”. המילים שחוזרות הכי הרבה: agent, model, mlx, server, agentic. בסרטון הזה יש 144 משפטים ו-2056 מילים לתרגול Shadowing. הדיבור נמשך 13:22. הדובר מדבר בקצב טבעי של כ-154 מילים בדקה, קרוב לשיחה יומיומית. רק 77% מהמילים נמצאות בין 3,000 המילים הנפוצות ביותר באנגלית, כך שאוצר המילים מאתגר.

אוצר מילים מרכזי בסרטון הזה

15 המילים המתקדמות ביותר בסרטון, עם ההגייה והמשמעות שלהן:

מילה	הגייה	משמעות
stack שם עצם	/stæk/	ערמה
distribute פועל	/dɪˈstɹɪbjuːt/	חילק
demo שם עצם	/ˈdɛm.oʊ/	דמו
fetch פועל	/fɛt͡ʃ/	הביא, השיג
silicon שם עצם	/ˈsɪləˌkɑn/	צורן
concise שם תואר	/kənˈsaɪs/	תַּמְצִיתִי
excite פועל	/ɪkˈsaɪt/	הלהיב, עורר
quantize פועל		מידוד
summarize פועל	/ˈsʌməˌɹaɪz/	סיכם
dedicate פועל	/ˈdɛdɪˌkeɪt/	הקדיש
comprise פועל	/kəmˈpɹaɪz/	כלל
bandwidth שם עצם	/ˈbændwɪdθ/	רוחב פס
navigate פועל	/ˈnæv.ɪ.ɡeɪt/	נִוֵּט
acceleration שם עצם	/əkˌsɛl.əˈɹeɪ.ʃən/	האצה
queue שם עצם	/kju/	תּוֹר

Phrasal verbs שתשמעו

מילה	משמעות
check out פועל	בדק
figure out פועל	הֵבִין, מצא תשובה

משפטים שכדאי לחזור עליהם

משפטים קצרים ושלמים מהסרטון שאפשר להשתמש בהם בשיחה יומיומית:

Here's the chat experience you're familiar with.
Let's start with the stack.
Let's now talk about the second challenge, concurrency.
Let's have a look at what the agent created.
Let's ask the agent to add them.

דקדוק בסרטון הזה

המבנים שהדובר משתמש בהם הכי הרבה, עם המילים המדויקות מהסרטון:

מבנה	בסרטון
הווה מושלם (Present perfect) have/has + past participle — פעולה שקרתה בעבר ועדיין יש לה חשיבות או השפעה עכשיו	have gone · you've seen · has seen
סביל (Passive voice) be + past participle — הדגש הוא על מה שקורה, לא על מי שעושה את הפעולה	is built · are not generated · is automatically sharded

הגייה ששווה לשים לב אליה

הדובר משתמש ב-21 קיצורים וצורות מקוצרות, כמו you're, I'm, we'll. אמרו אותם בצורה הקצרה, כפי שאתם שומעים אותם.

הצלילים של “sh” ו-“zh”: multiplication /ˌmʌltɪplɪˈkeɪʃən/, computation /ˌkɑmpjʊˈteɪʃn̩/, specialize /ˈspɛʃəˌlaɪz/, acceleration /əkˌsɛl.əˈɹeɪ.ʃən/, documentation /ˌdɑkjəmɛnˈteɪʃən/
מילים ארוכות — שימו לב להטעמה: multiplication /ˌmʌltɪplɪˈkeɪʃən/, concurrency /kəŋˈkʌɹənsi/, repository /ɹɪˈpɒz.ɪ.t(ə.)ɹɪ/, parameter /pəˈɹæm.ə.tɚ/, simulator /ˈsɪmjəˌleɪtɚ/

צלילים שדוברי עברית מתקשים בהם:

/w/ — שפתיים מעוגלות, לא /v/: workflow /ˈwɝkfloʊ/, whopping /ˈ(h)wɑpɪŋ/, bandwidth /ˈbændwɪdθ/, whichever /wɪt͡ʃˈɛvɚ/, straightforward /ˌstɹeɪtˈfɔː(ɹ)wə(ɹ)d/
/æ/ — פתוח יותר מה-“אֶ” העברית, לא כמו “a” ב-“cup”: stack /stæk/, batch /bæt͡ʃ/, parameter /pəˈɹæm.ə.tɚ/, bandwidth /ˈbændwɪdθ/, navigate /ˈnæv.ɪ.ɡeɪt/
/r/ — הלשון לא נוגעת בשום מקום, לא ה-“ר” הגרונית: distribute /dɪˈstɹɪbjuːt/, inference /ˈɪn.fə.ɹəns/, prompt /pɹɑmpt/, integrate /ˈɪn.tɪ.ɡɹeɪt/, concurrency /kəŋˈkʌɹənsi/

איך לתרגל עם הסרטון הזה

הקשיבו לכל הסרטון פעם אחת בלי לדבר, ורשמו את המילים שאתם לא מכירים.
התחילו במהירות 0.75×, תרגלו Shadowing משפט אחר משפט, וחזרו למהירות רגילה כשזה מרגיש קל.
הקליטו את עצמכם והשוו למקור, תוך תשומת לב למילים כמו stack, distribute, demo.

מהי טכניקת השאדואינג?

שאדואינג היא טכניקת למידת שפה מבוססת מדע שפותחה במקור להכשרת מתורגמנים מקצועיים ופופולרית על ידי הפוליגלוט ד"ר אלכסנדר ארגואלס. השיטה פשוטה אך עוצמתית: אתה מקשיב לאודיו באנגלית ילידית וחוזר עליו בקול רם מיד — כמו צל העוקב אחרי הדובר עם עיכוב של 1–2 שניות בלבד. בניגוד להאזנה פסיבית או תרגילי דקדוק, שאדואינג מכריח את המוח והשרירים בפה לעבד ולשחזר דפוסי דיבור אמיתיים בו זמנית. מחקרים מראים שזה משפר משמעותית את דיוק ההגייה, האינטונציה, הקצב, הדיבור המחובר, הבנת השמיעה ושטף הדיבור — מה שהופך אותו לאחת השיטות היעילות ביותר להכנה לIELTS Speaking ולתקשורת באנגלית בעולם האמיתי.

טכניקת Shadowing: קרא את המדריך המלא שלב אחר שלב →

Shadowing Practice: WWDC26: Run local agentic AI on the Mac using MLX | Apple - Learn English Speaking with Video

בחר מצב תרגול

הורד אפליקציה

WWDC26: Modernize your UIKit app | Apple

The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

What's new in Google Cloud in less than 1 minute

The most interesting "hack" in history...

Microsoft Surface vs. MacBook Air (Lab Tested)

Claude Code: The Advanced Guide (99% of Devs Skip These Features)

AI Concepts Every Product Manager Should Know in 25 Minutes | Crash Course

Jensen Huang & Satya Nadella on unmetered intelligence | Microsoft Build 2026

Is AI Doom Real... or Just Good Marketing?

Introducing Automations: always-on coding agents

MCP vs API: The protocol every developer needs to know

What are AI Agents?