Apple's Q3 2026 results are in, with the company's total revenue up by 16% from the year-ago quarter! Apple's Rosetta software tool is further nearing its end-of-life. And OpenAI rebuts Apple's trade secrets allegations.

• Apple announces record Q3 results.
• Apple stock opens down roughly 10% following mixed Q3 2026 results.
• Siri AI could come with a paywall for power users.
• First Apple Silicon-native CrossOver build in testing as Rosetta's end nears.
• What's the catch with the Apple Upgrade program?
• OpenAI rebuts Apple trade secrets allegations in new response with receipts.
• From OpenAI: "Apple is getting this wrong"
• Apple Photos' facial features prompt a $32.5B class-action lawsuit.

Picks of the Week

• Andy's Pick: Infuse Media Player
• Jason's Pick: Overcast
• Mikah's Pick: Pelican Marine Waterproof Phone Pouch

Hosts: Mikah Sargent, Andy Ihnatko, and Jason Snell

Download or subscribe to MacBreak Weekly at https://twit.tv/shows/macbreak-weekly.

Join Club TWiT for Ad-Free Podcasts!
Support what you love and get ad-free audio and video feeds, a members-only Discord, and exclusive content. Join today: https://twit.tv/clubtwit

Sponsors:

• joindeleteme.com/twit-biz
• cirasync.com/MacBreak

A year ago, I wrote a .NET Blog post about running GPT-OSS locally with Ollama and C#. That sample used IChatClient from Microsoft.Extensions.AI to build one of the most familiar Local AI scenarios: a chat application.

Chat is a great place to start, but Local AI is not limited to asking a small language model to write a poem or summarize a document.

Foundry Local can also run specialized models for workloads such as speech recognition. Even better, it manages the complete model lifecycle for your application: finding the appropriate model variant, downloading it when required, storing it in its local cache, loading it for inference, and unloading it when the application is finished.

In this post, we will build a small C# console application that uses an NVIDIA 0.6B Nemotron speech model to transcribe microphone audio in real time. The model runs locally, and the application receives partial and final transcription results while you speak.

Abstractions when possible, native capabilities when needed

In the previous Ollama sample, Microsoft.Extensions.AI gave us the IChatClient abstraction. That makes it possible to write chat code that can work with different AI providers without changing the application’s core logic.

Live audio streaming is slightly different. The AudioClient used in this sample belongs to the native Microsoft.AI.Foundry.Local SDK; it is not a Microsoft.Extensions.AI abstraction. We use the provider SDK here because live transcription sessions, raw PCM streaming, and interim results are Foundry Local specific capabilities.

This is a useful pattern for .NET AI applications:

• Use Microsoft.Extensions.AI abstractions when they match the scenario.
• Use the provider SDK when you need a specialized provider capability.

The two approaches complement each other.

What we are building

The application has a simple flow:

1. Initialize Foundry Local and resolve a speech model from its catalog.
2. Download and load the model.
3. Create a live transcription session.
4. Capture microphone audio as 16-kHz, 16-bit, mono PCM.
5. Stream the audio to the model and print interim and final results.

The complete sample targets .NET 10 and uses:

• Microsoft.AI.Foundry.Local.WinML for Foundry Local.
• NAudio to capture microphone audio.
• nemotron-speech-streaming-en-0.6b, an English streaming ASR model from the Foundry Local catalog.

You can find the complete working application here:

https://github.com/microsoft/Generative-AI-for-beginners-dotnet/tree/main/samples/CoreSamples/11-foundrylocal-live-transcription

See it in action

I show the complete application running on the .NET & AI Community Standup: Foundry Local resolves and loads the speech model, the application captures microphone audio, and interim and final transcription results appear in real time.

Watch the .NET & AI Community Standup

Let Foundry Local manage the model

The first important part is resolving the model through the Foundry Local catalog:

using Microsoft.AI.Foundry.Local;
using Microsoft.Extensions.Logging.Abstractions;
using NAudio.Wave;
using System.Threading.Channels;

var config = new Configuration
{
    AppName = "dotnet-local-ai-live-transcription",
    LogLevel = LogLevel.Information
};

await FoundryLocalManager.CreateAsync(config, NullLogger.Instance);

using var manager = FoundryLocalManager.Instance;
await manager.DownloadAndRegisterEpsAsync(); // EPs: execution providers for the detected hardware  

var catalog = await manager.GetCatalogAsync();
var model = await catalog.GetModelAsync(
    "nemotron-speech-streaming-en-0.6b")
    ?? throw new InvalidOperationException("Speech model not found.");

await model.DownloadAsync(progress =>
    Console.Write($"\rDownloading model: {progress:F2}%"));

await model.LoadAsync();

This is one of my favorite parts of the Foundry Local developer experience. The application asks for a model by alias, and Foundry Local takes care of the model files and the execution providers required by the available hardware.

On the first run, the model and the necessary execution providers are downloaded. If you keep the model in the Foundry Local cache, later runs can reuse it without downloading it again. There is no separate download script, no manually managed model folder, and no API key.

On the first run, Foundry Local downloads and caches the Nemotron speech model before starting the application.

Foundry Local also owns the catalog-specific metadata and file layout. For this scenario, the model should be obtained from the catalog and downloaded through model.DownloadAsync() instead of downloading the files separately from Hugging Face.

Foundry Local can select the model variant and execution provider that match the available hardware. That is a useful reminder that not every Local AI workload needs a large model or even a GPU.

Create a live transcription session

Once the model is loaded, we can get its AudioClient and create a streaming session:

var audioClient = await model.GetAudioClientAsync();
using var session = audioClient.CreateLiveTranscriptionSession();

session.Settings.SampleRate = 16000;
session.Settings.Channels = 1;
session.Settings.Language = "en"; // this Nemotron variant is English-only  

await session.StartAsync();

This is not batch transcription over a completed audio file. The session stays open and accepts raw PCM audio while the user is speaking.

The sample uses NAudio.WaveInEvent to capture the microphone at 16 kHz, 16 bits, and one channel. Because the NAudio callback is synchronous and session.AppendAsync() is asynchronous, the complete sample places audio chunks in a bounded channel and sends them to the session from a dedicated task. This respects backpressure and avoids creating an unlimited number of fire-and-forget operations.

The essential operation that feeds the model is:

var audioChannel = Channel.CreateBounded<byte[]>(new BoundedChannelOptions(50)
{
    FullMode = BoundedChannelFullMode.DropOldest
});

var appendTask = Task.Run(async () =>
{
    await foreach (var chunk in audioChannel.Reader.ReadAllAsync())
    {
        await session.AppendAsync(chunk);
    }
});

Read partial and final results as an async stream

The transcription results arrive through an async stream. Consume it from a different task than the one calling AppendAsync(), so that reading results never blocks audio capture:

await foreach (var result in session.GetStream())
{
    var text = result.Content?[0]?.Text;

    if (result.IsFinal)
    {
        Console.WriteLine();
        Console.WriteLine($"[FINAL] {text}");
    }
    else if (!string.IsNullOrEmpty(text))
    {
        Console.Write(text);
    }
}

Interim results can be displayed immediately while the user speaks. When the model completes an utterance, it emits a final result. This makes the API useful for experiences such as live captions, meeting notes, voice-controlled desktop applications, accessibility tools, and edge solutions with limited connectivity.

Here is the application already running, with the model loaded and live transcription active:

The application displays interim transcription in cyan and finalized text in white with the [FINAL] prefix.

The snippets above focus on each stage of the application. In the complete sample, resource cleanup is protected so it also runs after an exception. The simplified lifecycle looks like this:

await model.LoadAsync();
try
{
  using var session = audioClient.CreateLiveTranscriptionSession();
  await session.StartAsync();

  try
  {
    using var waveIn = new WaveInEvent();
    // Capture and stream microphone audio.
  }
  finally
  {
    await session.StopAsync();
  }
}
finally
{
  await model.UnloadAsync();
}

The sample uses Enter for a graceful shutdown. A production command-line application that supports Ctrl+C should handle Console.CancelKeyPress, cancel the active work, and allow the same finally path to complete.

The sample also demonstrates RemoveFromCacheAsync() so you can explicitly remove the downloaded model when you no longer want to keep it. In a normal application, keeping it cached avoids downloading it again on the next run.

Why run speech-to-text locally?

Local inference brings some practical advantages to this scenario:

• Microphone audio stays on the device.
• No cloud AI resource or API key is required.
• After the initial model download, inference can run without a network round trip.
• The streaming model can run through the CPU variant selected by Foundry Local.
• The application still uses familiar C# patterns: async/await, async streams, channels, and strongly typed SDK clients.

Local AI will not replace every cloud AI workload. Larger models, centralized management, elastic scale, and other cloud services remain important. But for privacy-sensitive audio, offline experiences, prototypes, and applications that need on-device processing, it gives .NET developers another very useful option.

Summary

Chat clients are usually the first Local AI demo and for good reason. They are easy to understand and fun to build. But Foundry Local is more than a local chat runtime.

It can manage and run different types of models, including specialized streaming speech models, directly from a C# application. You focus on the experience you want to build; Foundry Local handles much of the model lifecycle underneath it.

And yes, asking a local model to write a poem is still allowed. Now your application can also transcribe the poem while you read it.

Learn more

• Live audio transcription with Foundry Local: https://learn.microsoft.com/azure/foundry-local/how-to/how-to-live-transcribe-audio?tabs=windows&pivots=programming-language-csharp
• Complete C# sample: https://github.com/microsoft/Generative-AI-for-beginners-dotnet/tree/main/samples/CoreSamples/11-foundrylocal-live-transcription
• .NET & AI Community Standup: https://dotnet.microsoft.com/live/community-standup?category=ai
• Generative AI for Beginners .NET: https://aka.ms/genainet
• Previous post GPT-OSS, C#, and Ollama: https://devblogs.microsoft.com/dotnet/gpt-oss-csharp-ollama/

The post Beyond Chat: live Speech-to-Text with Foundry Local and C# appeared first on .NET Blog.

Everyone is waiting for AI training at work. It took me a hundred conversations to understand what they are actually waiting for, and it is not a course.

AI training at work is the most requested thing I hear about now, and almost nobody I meet has actually had any. I finished a session last month and a man waited until the room emptied before he came up to ask me something. That usually means the question is not about indexes.

He asked when his company was going to train them on AI.

Not whether. When.

A quick note. The people in this piece are composites, blended and reshaped so that no individual is identifiable. Nothing here refers to any specific person or organization.

He Was Not Being Lazy, and That Is the Interesting Part

My first instinct was the unkind one, and I am not proud of it. Learn it yourself. That is what the rest of us did.

Then we talked for a while and the unkind answer fell apart.

He had been at the same company for eleven years. In that time he had taught himself replication, then Always On, then two migrations he described in a way that made me wince in sympathy. Nobody had trained him on any of it. There had been no course, no rollout, no slide deck with a stock photo of a lighthouse on it.

So here is a man with a documented history of learning hard things without being asked to. And on this one thing, he is standing still.

That is not laziness. That is a signal. Something about this one is different, and it is worth working out what.

Every Other Skill Arrived Without a Warning Label

Here is the difference, and once you see it you cannot unsee it.

Nobody ever sent an email saying do not learn replication. There was no policy about indexes. When he stayed late reading about availability groups, the worst thing that could happen was that he was tired the next day.

AI did not arrive like that. For most people it arrived attached to a rule.

Sometime in the last two years, a lot of companies sent a version of the same email. Effective immediately, do not paste company data into these tools. Some went further and blocked them at the firewall. The email was usually correct, by the way. Somebody had already pasted a customer list into a chat window and everyone found out about it at the same meeting.

Every other skill he ever learned was neutral. This one had a memo about it.

Then came the part nobody talks about. The memo was never repealed.

Bans Get Abandoned. They Almost Never Get Withdrawn.

Watch what happens to a corporate ban over eighteen months.

Month one, it is enforced. Month four, the enterprise license gets signed and three teams are quietly using it. Month nine, an executive demos it on stage at the town hall. Month fourteen, there is a slide about AI in the annual strategy.

And in month eighteen, the original email is still the last written word on the subject.

Nobody ever sends the follow up. There is no memo saying the thing we banned is now encouraged, please carry on. That memo would require somebody to sign their name under a reversal, and reversals are the least popular document in any organization.

So the ban does not end. It just stops being enforced. And the difference between those two things is invisible from an executive floor and enormous from a desk.

The man in my session was not waiting for a course. He was waiting to be told he was allowed.

What Your Organization Genuinely Owes You

I want to be fair here, because the loud version of this argument is that everyone should stop complaining and go learn on Sunday, and that version is both smug and wrong.

If a company expects you to use a tool, the company owes you something. Four things, in fact, and none of them are a course.

A written yes. One sentence is enough. You may use these tools for these things, not for those things. Nobody needs a policy document with eleven appendices. They need one line they can point at when somebody asks what they think they are doing.

A place where mistakes are cheap. A sandbox, an anonymized copy, a scratch database that nobody bills for. You cannot learn where a tool goes wrong if the only place to find out is production.

Time that is actually protected. Two hours a week in the calendar, defended like a meeting with a client. Learning time that anyone can book over is not learning time. It is decoration.

Somebody senior being visibly bad at it in public. This one costs nothing and is worth more than the other three combined. People do not experiment when the only visible users are the ones who are already good.

Ask for those. They are reasonable, they are cheap, and asking for them is a completely different act from waiting.

And the Thing It Cannot Give You

Now the harder half.

Your organization can buy you a license, a course, a policy and a sandbox. It cannot buy you the hours. And the hours are the actual skill, because the tool is the one thing everybody already has.

Here is what I mean, and it happened to me.

I asked for help tidying a stored procedure that was slow. Inside it was a cursor walking a table row by row, updating a running balance. The suggestion that came back replaced the whole thing with a single set based UPDATE. Shorter, cleaner, faster, and I would have approved it in a code review without blinking.

It was also wrong. The cursor was accumulating. Each row depended on the row before it. The rewrite calculated every row against the same starting balance, so the numbers were tidy, fast, and completely fictional.

The tool was not confused about SQL Server. It was right about SQL Server. It was wrong about what the code was for. It had no way of being right about that. There is nobody in there to wonder why a person would write a cursor on purpose.

A course teaches you what the tool does. Only the hours teach you when it is lying to you with a straight face.

No training department can hand you that. It is not a module. It is a scar.

Who Do You Think Is Going to Write the Training?

This is the part I wish I had said to him properly at the time.

Your company will eventually run AI training. There will be a deck. There will be a session, probably on a Thursday, probably too long.

Somebody is going to build that deck. It will not be a vendor, because the vendor does not know what your systems are called. It will be somebody inside your company who already knows where the tool helps and where it quietly produces beautiful nonsense.

That person is learning right now. On a laptop. Without a memo. Being slightly wrong in private, on purpose, where it does not cost anything.

The training you are waiting for is currently being paid for by somebody who did not wait.

What I Would Actually Do on Monday

Send one email and ask for the line. Not a policy. A line. What am I allowed to use this for, and what is off limits. Whoever replies will be relieved somebody finally asked, because they have been wondering the same thing and outranking you does not make it clearer.

Practice on things that are not yours. Sample databases, public data, that side project you abandoned in 2019. You need reps, and reps do not require permission when there is nothing confidential in the room.

Keep a note of every time it was confidently wrong. Two lines each. What you asked, what it produced, why it was wrong. After twenty of those you will have something no course contains, which is a map of the failure modes in your own domain.

Then show somebody the list. Not the wins. The list of failures is more persuasive than any demo, and it is the fastest way to become the person they ask to build the training.

The Honest Version

I do think organizations are being unhelpful. The silence is real, it is cowardly, and it is costing people time. If you feel stuck because nobody has told you where the line is, you are not imagining it and it is not your fault.

But waiting is still a decision, and it is one with a price, and the price is paid entirely by you.

None of this is really about a tool. It is about who holds the judgment when the answer looks perfect and is wrong about the running balance. That question sits behind every one of the thirty essays in my book AI: Nobody’s in There. But we’re still in here. Every essay is free to read at pinaldave.com, and there is a paperback on Amazon if you would rather hold something real.

The man from that session emailed me a few weeks later. He had not been given any training. He had, however, started keeping the list of things it got wrong. He said it was now four pages long and that he had begun to enjoy it.

Nobody is coming with a certificate. That has been true of every useful thing you ever learned, and you already knew how this works.

This is not a training problem, it is a permission problem, and permission is the one thing you were always able to give yourself.

Reference: Pinal Dave (https://blog.sqlauthority.com/), X

First appeared on AI Training at Work: Nobody Is Coming

Today’s list had a bunch of fresh insights to learn from. I liked the perspective on model retention terms, working with agent teams, where the AI moat lives, and who builders are.

[article] Elevating Antigravity Agent skills with image generation. For now, skills represent the best way to steer the harness and avoid wasting tokens on unnecessary turns. Good example here.

[blog] Governed Growth, Part 2: The Retention Window That Quietly Shrank. Casey continues his exploration of an area you probably haven’t dug into much. Maybe you don’t read retention terms, but there’s some important stuff in there.

[blog] How I Work With 5 Coding Agents Simultaneously. I’d imagine that coffee is involved. This seems like reasonable advice for those orchestrating fleets.

[blog] Scaling real-time AI agents with session-aware load balancing. I haven’t seen this talked about much either. It’s not just about load balancing the requests, but sessions themselves.

[article] The Next AI Moat Isn’t a Better Model. This looks at physical AI (machines) and building learning systems. Really smart point about the “cost” of incorporating new models, and why the broader system is where value accrues.

[article] Engineering management is a career change, not a promotion. So much great advice here. We under-train managers, and many people don’t realize that it’s an entirely different job.

[blog] Introducing Database Operations Agents: The future of autonomous database management. These sorts of agents give everyone the opportunity to do a decent job, and database experts an extra superpower.

[blog] Microsoft Q4 Cloud Growth Rate Slips to 27%, RPO Soars 84% to $678 Billion. All the hyperscale clouds are doing great. AWS just nailed it too. Acceleration rates are different.

[blog] Securing a Go Supply Chain: The Pipeline That Holds in 2026. Are you playing offense or defense on your supply chain checklist? This approach feels like playing offense where you’re attacking the problem.

[blog] Who is a Builder? Anyone can be a builder, using this definition. And we’re seeing all sorts of people pick up this new class of tool to solve a problem with software.

[blog] Software abundance. Spot on. If you’re broadening your skills and embracing a growth mindset, you’re golden right now.

[blog] GenRec: Towards LLM-Native Recommendation at Netflix. They’ve got some statistically meaningful improvement from an LLM-backed ranker, as opposed to a traditional recommendation model.

Want to get this update sent to you every day? Subscribe to my RSS feed or subscribe via email below:

I released LLM 0.32 this morning, the most significant new version of LLM since the initial launch of the project. The new version includes support for visible reasoning traces, server-side provider tools, redesigned content-addressable SQLite logs, new models, and new features enabled by the OpenAI Responses API. I also released new versions of the llm-anthropic, llm-gemini, and llm-openrouter plugins, each with substantial updates of their own.

Headline features for LLM CLI users

Running LLM against reasoning models now displays their reasoning traces to standard error, so you can see what they are "thinking" without that information being included in the standard output that you might pipe to another tool. Add -R/--hide-reasoning to turn this off.

LLM includes support out-of-the-box for the GPT-5.6 model family, and the new default model used with llm "prompt" is now the inexpensive but capable GPT-5.6 Luna.

LLM calls can now use server-side tools from various providers. OpenAI provide a code execution environment as a server-side tool; LLM can now run prompts that benefit from that like so:

llm --tool CodeInterpreter 'Show current python and SQLite versions'

OpenAI also gets a WebSearch tool.

The llm-anthropic plugin adds WebSearch, WebFetch, CodeExecution, and AnthropicMCP, which looks like this:

llm -m claude-sonnet-5 -T 'AnthropicMCP("https://datasette.simonwillison.net/-/mcp")' \
  'how many rows in the blog_blogmark table?'

That causes Anthropic to execute MCP calls against my new datasette-mcp plugin as part of a single request/response interaction with their API.

The new llm openai endpoint command provides a tool for executing prompts against any OpenAI compatible endpoint as a one-liner. These aren't logged, which makes this a handy tool for running one-off prompts against anything that speaks the lingua franca of the LLM API world.

Here's how I use that to run prompts against Gemma 4 12B running in my localhost LM Studio API, via uvx (no LLM installation required) and mixing in the llm-tools-quickjs tool plugin for good measure:

uvx --with llm-tools-quickjs \
  llm openai endpoint http://localhost:1234/v1 -m google/gemma-4-12b \
  -T QuickJS 'Use QuickJS to multiply 3434 * 2434' --td

New features in the Python API

LLM's Python API previously required you to create a conversation and then send messages to it one at a time. This was an abstraction over the true nature of LLMs, where each request carries a complete history of the messages that came before it. That abstraction started to get in the way for some more advanced cases, so the new release introduces a model.prompt(messages=[]) parameter that can be used like this:

import llm
from llm import user, assistant, system

model = llm.get_model("gpt-5.6-luna")

response = model.prompt(messages=[
    system("You are a helpful pirate."),
    user("What is the capital of France?"),
    assistant("Paris, matey."),
    user("And Germany?"),
])
print(response.text())

LLM previously returned an iterable sequence of strings from each prompt. This worked great when models returned a string response, but failed to predict the weird shape that models would evolve towards. Today many models return a mix of reasoning text, output strings, tool calls, and even image attachments. With LLM 0.32 you can do this instead:

for event in model.prompt("Explain cats").stream_events():
    if event.type == "reasoning":
        print(f"[thinking] {event.chunk}", end="", flush=True)
    elif event.type == "text":
        print(event.chunk, end="", flush=True)
    else:
        print(f"Other event: {event}")

Combine these features and we can finally provide a robust implementation of the semi-standard OpenAI chat completions API, which I've now released as the llm-chat-completions-server plugin:

llm install llm-chat-completions-server
llm chat-completions-server --port 9000
# Server is now running on http://127.0.0.1:9000/v1

Now you can run prompts against LLM via that server, using the new llm openai endpoint command!

llm openai endpoint http://127.0.0.1:9000/v1 'hello' -m gpt-5.4-mini

The bigger challenge with that kind of API concerns logging. If we're going to support the pattern where the message sequence is appended to on every request, ideally we can avoid logging all of that duplicate JSON for every turn.

The solution is the new content-addressable message store, modeled after Git. You can see the new schema for that in the documentation, but the llm logs and llm logs --json commands have both been upgraded to convert that format back into something that's easy to consume.

And the rest

There is a whole lot more in this release. The 0.32 release notes are pretty comprehensive, and the notes for 0.32rc2, 0.32rc, 0.32a3, 0.32a2, and 0.32a0 should fill in any gaps.

Existing LLM plugins should all continue to work, but plugins that provide extra models will need to be upgraded to 0.32 in order to participate fully in the new streaming events system. There's a guide to implementing plugins with Structured messages and streaming events in the documentation.

I've updated some of my own plugins:

• llm-anthropic 0.26 adds support for the Claude 5 family of models, plus WebSearch, WebFetch, CodeExecution, and AnthropicMCP server-side tools.
• llm-gemini and llm-openrouter and llm-mistral are nearly there, releases coming soon.

I guess LLM is an agent framework now

Quite a few of the lower-level tools changes in this release were driven by the needs of Datasette Agent. When I started work on LLM, the term "agent" had such a vague definition that I refused to use it. In September 2025 I came around to the idea that "An LLM agent runs tools in a loop to achieve a goal" is well established enough now that I could stop avoiding the term entirely.

Tool chains can now pause for human approval and resume from a stored message history - both needed by Datasette Agent.

Looking at LLM today it's beginning to look very agent-shaped to me. There's something neat about having a CLI utility that can mix and match different tools from different sources with different models all as a one-liner, and that includes a Python library powerful enough to build systems like Datasette Agent and llm-coding-agent.

Maybe the next version of LLM will bake the concept of an "agent" into the core library. I'm still trying to figure out what that would look like.

Tags: projects, releases, ai, openai, generative-ai, llms, llm, anthropic