Ships vs. Slides: Silo Runs On-Device Today While Edge0 Runs a Render

In 2026 you often cannot tell a screen capture from a render. Video models like Minimax H3 will synthesize a convincing phone demo from nothing, so I cannot prove which one this is. But the cheapest thing to record is software that already exists, and when every other piece of evidence points away from a shipped app, the likelier read is a render of something they hope to make real later, not a capture of something that runs today. That gap, between the demo and the artifact, is the finding.

Contents

• Two ways to claim “AI runs on your phone”
• The Edge0 marketing: a large model, small working set, and a phone
• What’s actually in the Edge0 repo
• The founder’s own words: “coming soon”
• The paper that never came
• Meanwhile, Silo just does it
• Being fair: these are not the same bet
• The coup de grâce: X open-sourced the machine the hype runs on
• The bottom line

Two ways to claim “AI runs on your phone”

This week I put two open-source projects side by side, because one is getting loud attention for a capability the other simply ships, quietly, and has for over a year. Silo I can install and run. Edge0’s iPhone app, the thing in all the videos, I cannot find at all.

The loud one is Edge0 (https://github.com/Edge0-AI/Edge0). Its founder has been posting screencast-style, heavily produced clips of an iPhone allegedly running a 35B model fully on-device. One LinkedIn post is sitting at 3,599 likes as I write this, with hundreds of reshares. On X the same campaign is bigger still: a clip posted Sep 10, 2026 has 672K views, 10K likes, and nearly a thousand reposts.

The pitch is genuinely exciting: a large model, on a phone, no cloud. Note the small “No speed-up · 1x” label the author added in the corner, a pre-emptive answer to the “this must be sped up” objection. It’s the kind of detail you add when you anticipate disbelief.

The quiet one is Silo (https://github.com/stevederico/silo) by Steve Derico, a private, on-device AI chat app that has been live on the App Store since early 2025 (https://apps.apple.com/us/app/silo-private-ai-assistant/id6741248135). The name is common, there are other unrelated apps called “Silo” in the App Store, so to be clear, throughout this post I mean Derico’s app at those two links and nothing else. I have it installed on an iPhone XS running iOS 18, downloaded from the official store. No TestFlight. It works.

Putting these two next to each other is the clearest way I know to illustrate a distinction that AI hype makes easy to lose: the difference between shipping a capability and narrating one.

The Edge0 marketing: a large model, small working set, and a phone

Here is the clip that’s doing numbers. Note the framing, “Large model. Small working set. Only the parameters the current step needs are loaded into memory,” laid over an iPhone rendering Chinese text from an “Edge0-35B” chat UI:

It’s a compelling story, and the underlying idea is real research territory: stream a Mixture-of-Experts model’s weights from storage and only pull the experts a given token actually routes to, so the resident memory is a fraction of the full parameter count.

If you deliver that on a phone, you have done something genuinely harder than what anyone else is shipping to consumers.

“Phone-class memory” is not “runs on a phone”

Here is the exact rhetorical move, and once you see it you cannot unsee it. The Hugging Face model card for Edge0-8B-A1B leads with this (https://huggingface.co/Edge0/Edge0-8B-A1B-preview):

“Runs in phone-class memory: the full 4-bit checkpoint stays on storage and experts are streamed on demand, so only the active weights are in RAM, under 1 GiB… Works out of the box: base, LoRA and prerouter adapters ship together and load automatically via edge0.”

Every word is technically true and the conclusion your brain reaches is false. “Phone-class memory” describes a quantity of RAM, not a device. It means the active weights fit in roughly a phone’s worth of memory. That is real and it is good engineering. But the card never says iPhone, iOS, or Android, not once. And “works out of the box” answers which box in the same breath: “load automatically via edge0”, the framework that by its own README runs on Apple Silicon macOS and nothing else.

And “nothing else” is not my characterization. Three more lines from the same model card close the loop, all Edge0’s own words:

• The benchmark names the hardware. “Measured with examples/bench.py on a Mac mini M4 Pro, 24 GB.” Every headline number, 25 tok/s decode, 1428 tok/s prefill, 1.0 GiB peak, was measured on a desktop Mac with 24 GB of RAM, roughly two to four times what the iPhone in the demo ships with. The device under the numbers is not the device in the video.
• The use cases are server and desktop. “NVMe, internal flash… batch serving on a single commodity machine.” Phones do not batch-serve, and nobody calls an iPhone “a single commodity machine.”
• The Limitations section says it outright. “The MLX backend currently targets Apple Silicon; other backends are on the edge0 roadmap.” There is no phone backend. It is roadmap.

So the full ledger, quoted entirely from Edge0’s own documentation: the highlight says “phone-class memory” and names no device; the benchmark runs on a 24 GB Mac; the use cases are desktop and server; the Limitations concede no phone backend exists; and the founder says the app is “coming soon.” The marketing shows an iPhone. The documentation says Mac, desktop, roadmap. The number is honest; the device is fiction. Edge0 keeps saying “phone-class,” and has never shipped anything that runs on a phone.

Hype Train Loading?

This wasn’t a one-off post, either. It was a staged campaign. On Aug 12 the founder posted “35B parameters. One iPhone. No cloud. We trained Edge8-35B [sic], an ultra-sparse MoE with a jointly trained dynamic expert planner, and built an SSD-streaming inference engine around it,” with an iPhone demo clip attached. Then on Sep 1, quote-tweeting that same post, he pre-announced the date: “Something big is coming on September 10. A major open-source release from us.”

And note the name in that quote: Edge8-35B, not Edge0. That is what the post says, transcribed as written. “Edge8” appears nowhere in the shipped repo or on either Hugging Face model card, which call it Edge0-35B-A3B (https://huggingface.co/Edge0/Edge0-35B-A3B-preview) and Edge0-8B-A1B (https://huggingface.co/Edge0/Edge0-8B-A1B-preview). So either the founder typo’d the name of his own flagship model in the post that launched it, or the branding changed somewhere between the August teaser and the September release. Neither is damning on its own. But when the pitch is “we trained a 35B model and ran it on a phone,” and the model in the marketing does not share a name with the model in the repo, it’s one more place where the demo and the artifact don’t line up.

So the sequence is: Aug 12, tease “one iPhone, no cloud” with a clip; Sep 1, build anticipation with a countdown; Sep 10, drop the 672K-view video. That is a competent, deliberate product-launch cadence, and it’s hard not to read it as engineered for the platform’s feed. A teaser, a dated countdown, and a launch-day payload is precisely the rhythm that reward-farms an algorithmic timeline: each post reactivates the last, priming the reach the Sep 10 clip ultimately got. I can’t prove intent, and I won’t pretend to, but the shape is consistent with optimizing for distribution as much as for what should have been the release itself. (There was no release of the thing being demoed.) That makes the next part stranger, not less. The “major open-source release” that actually landed on Sep 10 is the thing whose repo we’re about to open, and the repo does not contain the app the campaign was selling.

The problem is what happens when you open that repo.

What’s actually in the Edge0 repo

I cloned Edge0 and read it. It is a backend-isolated Python inference framework: a CLI and a server, edge0 = "edge0.cli:main" in pyproject.toml. Its real, present-tense capability is MLX on Apple Silicon Macs. It vendors exactly one file from Apple’s mlx-lm (qwen3_next.py, kept byte-identical outside added routing hooks) and one from the Ling 3.0 MLX implementation, both correctly attributed in NOTICE. The novel parts it claims are a “prerouter” that predicts expert routing and an SSD expert-offload streaming path.

You don’t even have to go digging to see the gap. Edge0’s own README Requirements section says it outright:

Snapshot as of 2026-09-11. The repo can change at any moment, and it may well grow more platforms later. But at this time, an Apple Mac hardware focus is what they themselves claim.

“macOS with Apple Silicon… no other platforms are supported yet.” iOS is a different platform. The project documents, in its own words, that it does not run on a phone. That brings us to two things that are conspicuously absent:

1. There is no iOS app anywhere in the tree. No Swift, no Xcode project, no .ipa, nothing. On every branch (main plus three fix/* branches), the only thing “iOS” about the project is the marketing.

2. There is no CUDA either, despite the roadmap language. EDGE0_BACKEND=cuda is wired to a stub that raises ImportError("the CUDA backend is not implemented yet"). The backends/cuda/ directory the README calls a “reserved slot” does not exist on disk. It’s scaffolding-as-if-shipped, the same instinct, scaled up, that produces an iPhone demo for an app that isn’t written yet.

So the thing in the videos, an iOS app, is not the open-source project as published. If the demo is real, it’s running separate, unreleased code. If it isn’t real, it’s a render.

The founder’s own words: “coming soon”

You don’t have to take my word for it. Pressed in the comments, the founder (Xiaodong “Samuel” Zeng, “Founder, edge0.ai”) says it plainly:

Read his point 2 carefully: “The next version (coming soon) will open-source the app layer, including the phone app and the desktop app… you can also fairly easily vibe-code your own iPhone app.” That is a concession that the phone app does not exist as a shipped artifact. The demo ran ahead of the code.

And the “looks AI-generated” instinct matters here in a specific, technical way: a real prototype is the single easiest thing on earth to screen-record. If a working iOS build existed, even a janky internal one, capturing it is less effort than generating a synthetic clip. Choosing a render over a capture is the behavior of someone who has no capture to make. That is not proof, but it is a strong prior, and it points the same direction the repo does.

The second voice in that screenshot is worth reading too. A commenter walks the same path I did, independently, and lands a sharper technical point than I had: Qwen3.5-35B-A3B’s original config routes eight experts per token; Edge0’s 35B prerouter uses four, and substitutes predicted routing during decode. Keeping the weights on SSD is not the same as preserving the original model’s execution. “The model, intact, on your phone” and “a re-routed, half-active approximation streamed from disk” are different claims, and only one of them is being marketed.

The paper that never came

Go back to that Aug 12 post and read the last line. The promise was three artifacts, tied specifically to the on-device iPhone demo: “Model, runtime, and paper: open source soon” (https://x.com/SamuelZengML/status/2087562269807030754).

Two of the three arrived in some form. The models are on Hugging Face and getting real downloads (thousands a month across the 35B and 8B previews). The runtime is the MLX framework we just walked. The paper for that on-device work is the one that never showed up.

Now, let me be fair, because “he has no paper” would be plain wrong, and I’d rather get this right than score a cheap point. Xiaodong Zeng does publish real research. He is co-author on a real, formatted preprint: “Unifying Speech Recognition, Synthesis and Conversion with Autoregressive Transformers” (arXiv:2601.10770, https://arxiv.org/abs/2601.10770, submitted Jan 15, 2026). It is a proper technical report with an abstract, methods, and a citation trail, the AutoArk-AI “General-Purpose Audio (GPA)” project. Zeng is listed as one of five authors (Runyuan Cai, Yu Lin, Yiming Wang, Chunlin Fu, Xiaodong Zeng); whether he is the lead or a contributor, I cannot say from the byline alone. Either way, this establishes plainly that the man can and does co-author papers.

Which is exactly why the gap matters. That preprint is not the paper he promised. It is a speech and audio foundation model (TTS, ASR, voice conversion) from a different project, AutoArk/GPA, not the Edge0 MoE-streaming work. The Aug 12 post promised a paper for Edge8-35B, the ultra-sparse MoE with the SSD-streaming engine, the thing running on an iPhone in the clip. That Edge0 paper does not exist. I searched the whole repo tree, on every branch: no PDF, no paper/ directory, no citation, no BibTeX, no arXiv link. What ships under the “paper” heading is a handful of docs/*.md engineering notes (architecture.md, moe.md, prerouter.md, streaming.md), which have no abstract, no evaluation methodology, no baselines, no ablations, nothing you could use to reproduce or falsify a number.

And notice which claim the Edge0 paper would have been forced to defend. The Aug 12 demo advertised 44 tok/s at ~1.06 GB peak memory, on one iPhone. The shipped Hugging Face card, by contrast, reports its numbers on the MLX backend running on Apple Silicon Macs (14.9 to 17.7 tok/s decode for the 35B). Those are different machines and different figures, and nothing published reconciles them. A paper is exactly the document where you would have to.

That is the tell, and it’s the cleanest one in this whole investigation because it requires no guessing about intent, only an inventory of promised versus delivered. Zeng clearly knows how to co-author and publish a preprint. He did it for audio. The Edge0 paper is missing because it is the only promised deliverable that would have forced someone to show the iPhone number is real. The models shipped, the Mac runtime shipped, and the one artifact that would substantiate the pocket-sized claim is the one that’s still “coming.”

Meanwhile, Silo just does it

Now open Silo. The contrast is total, and it’s visible in the least glamorous place imaginable: the commit log.

• First commit: 2025-01-31. Seventy-six commits. A live App Store listing (id6741248135). A full native Swift/SwiftUI Xcode project.
• It runs GGUF models via llama.cpp on Metal GPU, with llama.xcframework and whisper.xcframework committed as the actual engines.
• The 2026 history is dense with boring work: “Fix decode failures after voice/chat by resetting KV cache each turn,” “Remove dSYMs / reduce binary size,” “Fix concurrency warnings,” a whisper.cpp speech pipeline merged in July, then App Store localization into ~40 locales on 2026-07-13.

Nobody fabricates a “reduce binary size” commit. That is the texture of a real product under maintenance, the unphotogenic middle of shipping, which is exactly the part a hype reel never contains. The CHANGELOG even records Silo trying MLX and then dropping it (“Remove MLX engine”, v1.2.5) in favor of llama.cpp, because llama.cpp was the path that actually ran on the device.

Silo is not claiming novel research. The codebase acknowledges what it’s built on: llama.cpp and whisper.cpp are vendored in the tree outright, and Unsloth’s quantized releases are credited up front. It is an honest integration, and integration shipped beats novelty narrated.

Being fair: these are not the same bet

It would be cheap to end there, so let me be precise about what each project is actually attempting, because they are not competing for the same trophy.

1. Different engineering bet. Silo runs small models (Gemma 4 E2B, Ministral 3B, LFM 2.5, in the 1.2B-to-~4B range) that fit comfortably in phone RAM via llama.cpp. That is the pragmatic, shipping-today path. Edge0’s distinctive pitch is the harder problem: streaming a 35B MoE with SSD expert-offload and prerouter prediction so a big model runs on constrained hardware. If Edge0 actually delivers that on-device, it is technically more ambitious than what Silo does. The whole question the Edge0 saga raises is whether that ambition is implemented or narrated, and so far the repo, plus the founder’s own words, say narrated.

2. Different games entirely. Silo isn’t claiming to have invented anything; it wins on shipping. Edge0 is claiming novelty (the prerouter, the offload) but hasn’t shipped the consumer artifact that would let anyone test the claim. One project can be judged by running it. The other, for now, can only be judged by reading its marketing against its source tree.

And a fairness note on the video itself: “looks AI-generated” is a subjective read, and modern mockup-to-motion tools can render an uncanny clip from a real Figma prototype that was never a running app. That is still “no working app,” design-vaporware rather than pure fabrication, but the distinction barely survives contact with the founder’s own “coming soon.”

The coup de grâce: X open-sourced the machine the hype runs on

Here is where the story stops being about two AI projects and becomes about the attention economy they float in. It’s the part I couldn’t have written a year ago, because the evidence wasn’t public.

Earlier I flagged the Edge0 campaign’s cadence (Aug 12 teaser, Sep 1 countdown, Sep 10 drop) as “consistent with optimizing for distribution,” and said I couldn’t prove intent. I still can’t prove intent. But I no longer have to speculate about what the platform rewards, because xAI open-sourced the For You ranking algorithm, and it landed on my disk in the same window this whole saga played out. The repo (https://github.com/xai-org/x-algorithm) has a CI agent committing “Open-source X Recommendation Algorithm” roughly daily through late August 2026. It is a real, substantial codebase: Rust and Scala, hundreds of source files, tests that compute expected scores, and refreshingly honest inline comments that correct common misreadings. In other words, it passes the exact “believe the source tree” test that Silo passes and Edge0’s missing iOS app cannot even take, because there is no iOS source tree to read.

And that transparency lets us do something delicious. We can take a viral AI-hype campaign and check it, line by line, against the scoring function it was optimized for.

The weights live in home-mixer/params/param.rs and are applied in home-mixer/scorers/ranking_scorer.rs. Each one multiplies the model’s predicted probability of an action, not raw counts, a distinction the xAI authors are at pains to make in the comments. Here are the defaults that matter:

Negative signals are enormous by comparison (Report -234, Mute -58.8, Not-interested -43.2, Block -31.2), but, as the authors note, the baseline probability of a report is over 1000x lower than a like, so the large weight mostly exists to let a rare signal register at all. Two more structural facts from the same files: out-of-network posts are discounted to 0.75x (OonWeightFactor) but new users get a reach boost for out-of-network content, and a post_unexplored novelty term rewards content a viewer hasn’t seen yet.

Now re-read the Edge0 campaign with that table in hand. It is difficult to design a better key-fit to this objective function if you tried:

• A reply or a quote is worth 10x a like (5.0 vs 0.5). So the optimal post is not likeable, it’s disputable. “35B parameters. One iPhone. No cloud.” is a claim engineered to be argued with. And it worked exactly as the weights predict: the 672K-view post carries 387 replies and 978 reposts/quotes, the two single highest-weighted actions in the entire system. Every commenter saying “wait, there’s no app” and every skeptic quoting it to debunk it was feeding the ranker the most valuable signal it has.

  Controversy is not a bug of this campaign; it is the mechanism.

• Following the author scores 4.0. That is nowhere near eighth-of-a-like territory; it’s the third-highest signal on the board. A “founder building something big, drop coming Sep 10” arc is precisely how you convert a one-time viewer into that 4.0 follow event.

• Novelty is rewarded, and the countdown manufactures it. The post_unexplored boost favors fresh content; a staged three-act sequence produces a stream of new, high-engagement posts, each reactivating the account and priming the next.

• Even the “No speed-up · 1x” label is engagement-optimal. It pre-empts the “it’s faked” reply, but a disbelieving reply still scores 5.0.

  There is almost no way for engagement to lose here. Belief reposts; disbelief replies; the algorithm pays out on both.

I want to be careful and fair, because that is the whole point of this post. I cannot prove the Edge0 team read ranking_scorer.rs and reverse-engineered their campaign from it. They may simply have good marketing instincts that happen to align with what X rewards. The weights, after all, are tuned to reflect genuine human engagement, so “what games the feed” and “what humans argue about” are the same thing by construction. That convergence is exactly why I can’t call it intent.

And a note on timing, because it is the one part of this that isn’t speculation:

The weights in that table are not a reconstruction after the fact. They are what the repo said during the campaign: I pinned them to commit 7ba7768, dated Sep 1, 2026, the countdown day itself. Anyone who wanted to know what the For You feed paid out for, in the exact window between the Aug 12 teaser and the Sep 10 drop, could clone the repo and read the numbers off param.rs. That is the whole point. No inference about what X rewards was required of anyone, because X had published it.

Since then X has started building a countermeasure: a per-viewer weight perturbation switch (WeightPerturbationSigma / WeightPerturbationSalt in param.rs, applied by a perturbed() path in ranking_scorer.rs) that randomly nudges each action weight up or down per user, seeded by an MD5 of the viewer id. It is defaulted to 0.0 — off — so the weights are still exactly the numbers above. But building the knob at all concedes the function is gameable. The transparency window may be closing as X learns to fuzz the weights. It was wide open in August and early September.

But here is the death-knell for taking these hype reels at face value: it no longer matters whether they read the source or not. The open-sourced algorithm proves that a disputable, novel, follow-baiting claim, true or false, shipped or rendered, is mechanically the highest-scoring thing you can post. The incentive to manufacture exactly this kind of vaporware is now codified in public. The exact weights shift over time as X tunes them, but the scoring function is right there for anyone to clone, read, and check. An AI-hype marketing team optimizing against that function will be pulled, by gradient, toward bold unfalsifiable claims and away from boring shipped software, because “I quietly maintained an app for a year and fixed a KV-cache bug” scores a rounding error next to “35B on your iPhone, no cloud,” and the machine that decides who gets seen now says so out loud.

That is the trap the whole field is in, made legible. The render out-scores the artifact by design. Which brings us, finally, to what to do about it.

The bottom line

Private, offline, on-device iOS LLM chat is a solved, shippable, App-Store-approved thing today. One developer proved it, in public, with a year of visible commits and an app I can install on a six-year-old iPhone. That is the strongest possible reality-check against Edge0’s “someday soon” reels: the bar they are marketing toward has already been cleared, and you can verify it by installing the app rather than by watching a video.

Whether Edge0’s specific, harder claim, a 35B MoE streamed on-device with predicted routing, is real remains unproven. Given an apparently AI-generated demo, a repo with no app in it, a founder conceding the app is “coming soon,” and a routing scheme that quietly halves the active experts, skepticism isn’t cynical. It’s the correct default until there’s an artifact to run.

The engagement numbers invert the merit. The render pulls 3,600 likes on LinkedIn and 672K views on X, while the app that actually ships never generated a comparable wave. That gap, attention flowing to the thing that photographs well rather than the thing that works, is the actual story, and it’s not unique to these two repos. It’s the condition of the whole field right now, and, as xAI’s own source now confirms, it’s the condition the ranking machine actively selects for. The antidote is boring and durable, and it’s the same move three times over: clone it, run it, read the commits, and believe the source tree over the sizzle reel. That’s how I know Silo is real, how I know Edge0’s app isn’t there yet, and how I know exactly what the feed pays out for. The code doesn’t do marketing.

Sources

• Edge0 repository: https://github.com/Edge0-AI/Edge0

• Edge0-8B-A1B-preview model card (“phone-class memory”, “works out of the box via edge0”): https://huggingface.co/Edge0/Edge0-8B-A1B-preview

• Edge0-35B-A3B-preview model card: https://huggingface.co/Edge0/Edge0-35B-A3B-preview

• Edge0 founder’s X demo post (672K views, Sep 10 2026): https://x.com/SamuelZengML/status/2097861839287927139

• Edge0 founder’s LinkedIn demo post (3,599 likes): https://www.linkedin.com/posts/xiaodongzeng_ondeviceai-edgeai-moe-ugcPost-7503676949815275521-4ZNY/

• Edge0 founder’s Aug 12 2026 X post promising “Model, runtime, and paper” on iPhone: https://x.com/SamuelZengML/status/2087562269807030754

• Xiaodong Zeng et al., “Unifying Speech Recognition, Synthesis and Conversion with Autoregressive Transformers” (AutoArk-AI / GPA, arXiv:2601.10770, technical report): https://arxiv.org/abs/2601.10770

• Silo repository: https://github.com/stevederico/silo

• Silo on the App Store: https://apps.apple.com/us/app/silo-private-ai-assistant/id6741248135

• llama.cpp: https://github.com/ggml-org/llama.cpp

• Apple mlx-lm: https://github.com/ml-explore/mlx-lm

• Qwen3.5-35B-A3B config (routed experts per token): https://huggingface.co/Qwen/Qwen3.5-35B-A3B/blob/main/config.json

• Edge0 35B model definition: https://github.com/Edge0-AI/Edge0/blob/main/src/edge0/models/edge0_35b/__init__.py

• Edge0 prerouter implementation: https://github.com/Edge0-AI/Edge0/blob/main/src/edge0/prerouter/install.py

• xAI open-source X recommendation algorithm: https://github.com/xai-org/x-algorithm

• X ranking weights, campaign-era state (pinned to commit 7ba7768, Sep 1 2026, the countdown-day snapshot): https://github.com/xai-org/x-algorithm/blob/7ba7768/home-mixer/params/param.rs

• X weighted scoring logic, campaign-era state (pinned to commit 7ba7768, Sep 1 2026): https://github.com/xai-org/x-algorithm/blob/7ba7768/home-mixer/scorers/ranking_scorer.rs

• X per-viewer weight-perturbation params, added after the campaign (pinned to commit 6bb4594, Sep 12 2026, defaulted off): https://github.com/xai-org/x-algorithm/blob/6bb4594253cdfa9ea19983a54a401d5ce8f8275d/home-mixer/params/param.rs

• Elon Musk announcing the algorithm’s open-source release (May 15 2026, nearly 44M views): https://x.com/elonmusk/status/2055277918633562153

For readers who did not know the For You algorithm is public at all: it was open-sourced on May 15, 2026, and the announcement alone drew nearly 44M views. Most people neither know nor care that the ranking machine is readable. It is mostly reference material. But it is real, it is dated, and anyone who wants to check my math against the source can.