Go back

// article

Apple's Built-in LLM Sucks, Mostly

good at one thing...

Play
Transcript

00:00 So, full disclosure, I am notoriously slow to upgrade my operating system, and Apple just announced that macOS 27 is coming. I think it’s called Golden Gate or Golden Bridge or something like that. So, of course, today I finally upgraded to 26 Tahoe, and the first thing I really wanted to check out was Apple’s Foundation Models Framework. So, if you’re not familiar with this and you’re on Tahoe, you have a little LLM running on your machine. It powers Siri and a bunch of other things, and you can tap into it. So, you know, I went to their website. There’s a bunch of Swift stuff here, and I like Swift enough, but here’s the thing that I learned. The LLM is really stupid. It’s really tiny, and it’s got like a context window of 4K, I think.

01:00 So, what’s really cool is I found this thing called “AppFull” or “AppFell” (Apfel). I’m not entirely sure, and we’re going to take a look at that in this video. Now, this is by a developer named Franz, and there’s his last name. And I’m going to go with Eisenhofer, which is, I’m sorry, Franz, I probably butchered that. But the repository where AppFull is, is in this Arthur Fischl repository, and I’ll have links to all this in the description. And he’s been going to town. He’s got all sorts of AppFull stuff and what he calls sister projects, and it’s really, really cool, and you should look at them all. But for now, I’m going to focus on AppFull, which, again, is really cool. And it just lets you install this little Swift CLI that lets you tap into the local LLM that’s already running on your machine, the foundation models. So, to install it, you just do brew install AppFull. So, we’re going to go ahead and install that with Homebrew, clear out the console, and there are three ways that we can run Apfel.

02:08 And the first one we’ll take a look at is chat. So, we get there with Apfel, double-tack chat. I’m going to say, write a Python function that reverses the string. It’s going to come back with some Python. I’m not that great at Python. This looks pretty good. I’m going to say, rewrite it in JavaScript. So, note that I’m saying it. I’m not saying anything else. And so, we have some amount of context history here. We have some amount of memory, and that’s really cool. It wrote it, and it’s not the best in the world, but this will do. It works. It totally works. I’m going to quit the chat by saying quit. I’m going to clear out the console.

02:52 The next way we can run this is Apfel serve. And what’s really interesting about this is it is using the exact same port number as Olama. And that should tell you something. You can, if you’re writing code that’s running against Olama or OMLX or anything that’s using, like AI SDK or something like that, that’s OpenAI compatible, you could run this and you could run that code against it. So, if I click here on models and load it up, we can see cool, I got my models and all as well, we’re running against the Apple Foundation model. Cool. So, I’m going to close that and we’re going to take a look at the last one, which is the CLI version, and this is the simplest one, but I actually think it’s the one with the most potential.

03:42 So, what I’m going to say is, hey Apfel, what is the weather in Chicago? And this is, this is going to fail, not horribly, it’s going to be like, why don’t you check a site that has the weather, because it has no access to the internet, it has no tools, it doesn’t have anything. It’s, it’s definitely not the dumbest model I’ve ever run on my machine, but it’s pretty stupid, but it does turn out, it’s actually pretty good at one thing. So, I’m going to CD into, so I have this OSS repos where I just kind of keep a bunch of repositories that I’m pulling from GitHub and whatnot, that I’m keeping track of. So, I’m jumping into ASTEP C++, what I’m going to do is I’m going to say cat build all SH, which is a shell file here, I’m going to pipe that to Apfel, I’m going to say TACQ, which should suppress any tool call output. I’m going to say TACQ, which is a system prompt, and I’m just going to say explain this code. All right, that took maybe five seconds and I’m just going to say this looks pretty good to me. I’m going to clear this out.

05:00 And what I realized is I could take this and then I could pipe that further to let’s say a build all markdown. And if I cat build all markdown, there it is, everything’s there. It’s already in markdown. That’s great. So, I’m going to paste this in, but what it’s doing is saying git log, the latest 10, and then the exact same command structure that I had, but summarize this git log in two to four sentence groups, some changes, blah, blah, blah. And so it’s going to look at the git log, and it’s going to tell us what it’s about in a nice little paragraph. There you go. I’m going to assume this is accurate information. I’m not going to double check it right now, but this led me to the next thing I want to show you. So I’m going to clear this out. It’s going to cd into my dev tools. I’m going to touch a new file called what’s up dot sh. And then I’m going to open that up and set. Now I’m just going to drop in this code that I wrote.

06:06 And what it’s basically doing is I have this directory called OSS repos that just has a bunch of open source repositories that I’m keeping track of. And then my output directory is my obsidian vault. And I’m saying, you know, create a file, OSS summary, today’s date and the markdown. And then I basically just, I just iterate through the root directory. I make sure it’s a git directory. I pull the latest and then I do that almost the exact same, but I went with 15. Summarization of the git log. And then I just output that to that file. So we’re going to try that out. I’m going to make sure that guy is executable. And then I’m just going to symlink that on my machine. So I can just be anywhere and run what’s up. So just to make sure that it’s not tied to this directory, I’m in my home directory. I’m going to say, what’s up? And I’ll load up obsidian while that’s running. And it’s already started. It is working on creating this file for me. So there is my groovy little, hey, this is where the open source repository that I’m interested is at. And so I’ll load it up on my phone because I run live sync in the house. So I can put that on a cron job and just have it run every day and tell me how things are going in this open source repository. And at the end of the day, that’s what it is. That is what the Apple Foundation model is actually good at. It is actually good at summarizing things.

07:52 And if you get a little creative with it, you could have it summarize a bunch of stuff. You could have it summarize those summaries. So I do think there’s potential here. It’s not going to change your life. But with the upcoming operating system update, if you watch the WWDC presentations, it does seem like, I guess it’s going to be some sort of distilled from Gemini models. So they are making some updates there. So I think it’s a good time to start playing with this if you haven’t played with it, because we may see some vast improvements in the near future.

Apple quietly ships a language model with macOS Tahoe. Naturally, the first thing I wanted to do after upgrading was see how useful it really is.

After experimenting with it for a while, I discovered two things:

  1. It’s much smaller than the models most of us are used to.
  2. It’s surprisingly good at one specific task.

What Are Apple’s Foundation Models?

If you’re running macOS Tahoe, you already have a local language model sitting on your machine. Apple exposes this through the Foundation Models framework, allowing applications to interact with the same model used by Apple Intelligence and Siri.

On paper, this sounds pretty exciting:

But there are some limitations.

The model itself is tiny compared to what most local AI enthusiasts are used to running. It has a relatively small context window and isn’t designed to compete with larger models from Ollama, MLX, or cloud providers.

Still, that doesn’t mean it’s useless.

Enter Apfel

While looking for ways to experiment with the framework, I came across Apfel, a Swift command-line utility that provides an easy interface to Apple’s Foundation Models.

Created by Franz Enzenhofer and hosted in github, Apfel exposes the built-in model through several different interfaces.

It turns out to be a really elegant little tool.

Installation

Installing Apfel is as simple as using Homebrew.

Terminal window
brew install apfel

Once installed, you have three different ways to interact with the model.

Option 1: Chat Mode

The first mode is an interactive chat.

Terminal window
apfel --chat

For example, I asked it to write a Python function that reverses a string.

Terminal window
Apple Intelligence · on-device LLM · apfel v1.6.0
────────────────────────────────────────────────────────
Type 'quit' to exit.


you› Write a python function that reverses a string
 ai› Certainly! Here is a Python function that reverses a given string:




def reverse_string(s):
    return s[::-1]


# Example usage:
original_string = "hello"
reversed_string = reverse_string(original_string)
print(reversed_string)  # Output: "olleh"

Then I followed up with:

Terminal window
Rewrite it in JavaScript.

Without restating the original prompt, the model understood the context and produced a JavaScript version.

Was it amazing? No. Was it correct? Mostly. And that’s good enough for simple tasks.

Option 2: OpenAI-Compatible Server Mode

The next mode is where things become interesting.

Terminal window
apfel --serve


apfel server v1.6.0
├ endpoint: http://127.0.0.1:11434
├ model:    apple-foundationmodel
├ cors:     disabled
├ origin:   localhost only (http://127.0.0.1, http://localhost, http://[::1])
├ token:    none
├ health:   public
├ max concurrent: 5
├ debug:    off
└ ready


Endpoints:
  POST http://127.0.0.1:11434/v1/chat/completions
  GET  http://127.0.0.1:11434/v1/models
  GET  http://127.0.0.1:11434/health


2026-06-17T11:40:55-0500 info Hummingbird: [HummingbirdCore] Server started and listening on 127.0.0.1:11434

Apfel exposes the model using the same API conventions as Ollama.

That means tools and libraries that already support OpenAI-compatible endpoints can potentially talk to Apple’s local model with very little effort.

Things like:

Neat.

Option 3: Command-Line Mode

You can simply pass a prompt directly to Apfel.

Terminal window
apfel "What is the weather in Chicago?"


I'm sorry, but I don't have real-time access to current
weather information. You can check the latest weather
forecast for Chicago by visiting a weather website,
app, or using a weather service like Weather.com,
AccuWeather, or the National Weather Service.

The model has:

It quickly reminds you that this isn’t GPT 5.5 (or even GPT 3).

Turns out the model is pretty good at one thing

Summarization. That’s where this tiny model gets useful.

Pipe the contents of a file to it

cat somefile.sh | apfel -q -s "explain this code"

Within seconds, I get a concise explanation of what the script does. Even better, the response comes back in markdown. Which means I can redirect it straight into a file.

cat somefile.sh | apfel -q -s "explain this code" > markdown.md

Summarizing Git History

There is a demo in the github repo called gitsum that summarizes a git log.

Terminal window
git log -15 | apfel -q -s "Summarize this git log in 2-4 \
sentences. Group relate d changes (features, fixes, \
refactors, docs). Mention what was built or changed, \
not individual commit hashes. Be specific about what \
happened. No bullet points."

The results are surprisingly good.

Rather than reading fifteen commit messages, I get a paragraph explaining what’s actually changed.

Practical use case

I keep a local directory full of oss repositories that I am interested in hearing about.

Something like:

oss-repos/
├── project-a
├── project-b
├── project-c
└── ...

So I wrote a shell script.

The script:

  1. Iterates through each repository.
  2. Pulls the latest changes.
  3. Collects recent commits.
  4. Sends them to Apfel.
  5. Generates markdown summaries.
  6. Writes everything into my Obsidian vault.
#!/bin/bash


ROOT_DIR="$HOME/oss-repos"
OUTPUT="$HOME/obsidian/oss-summary-$(date +%Y-%m-%d).md"


cat > "$OUTPUT" <<EOF
# OSS Summary


Date: $(date +"%B %d, %Y")


EOF


for dir in "$ROOT_DIR"/*; do
    [ -d "$dir" ] || continue
    [ -d "$dir/.git" ] || continue


    repo=$(basename "$dir")
    echo "Processing $repo..."


    summary=$(
        cd "$dir" || exit
        git pull >/dev/null 2>&1
        git log --oneline -15 |
        apfel -q -s \
        "Summarize this git log in 2-4 sentences. Group related \
        changes. Mention what was built or changed and the date, \
        not commit hashes. No bullet points."
    )


    cat >> "$OUTPUT" <<EOF
## $repo


$summary


EOF


done


echo "Wrote summary to $OUTPUT"

Running it creates a file like:

oss-summary-2026-06-17.md

Inside are summaries for every repository I’m tracking.

So is Apple’s Local AI Good?

That depends on what you’re expecting. If you’re hoping for GPT-4-level intelligence, you’ll probably be disappointed. The model is small. Its context window is limited. And it doesn’t have tools or internet access.

But for tasks like:

…it performs remarkably well. And because it’s already running on your machine, the cost is effectively zero.

Looking Ahead

Apple has already announced the next version of macOS, and judging from the WWDC presentations, it appears future Foundation Models may incorporate technology derived from Google’s Gemini models.

If that’s true, we could see some substantial improvements in the near future. Which makes now a great time to start experimenting. The current model won’t change your life. But if Apple continues improving these local models, they could become an incredibly useful building block for developers.

Share this post on:
Share this post via WhatsAppShare this post on FacebookShare this post on XShare this post via TelegramShare this post on PinterestShare this post via email
Previous
What We Didn't Learn from Walter Pitts
Next
OpenTUI: Responsive Terminal