# Three posts, three numbers, 1000+ stars: how Locals squeezed into the most crowded niche · GitHub open source projects

> Source: https://stringers.io/en/github/gh_Generated-Computers__Locals.html (Stringers / 什么值得做, generated 2026-11-08)
> Stringers answers one question every day: what small product can one or two people build in a few months and actually make money from. Numbers come from 15 databases we collect daily, each with source and date.
> For agents: these verdicts and the underlying databases (verified revenue, App Store / Google Play charts, ad libraries, GitHub, Product Hunt…) are queryable live over MCP — tools today / hot / products / directions / direction / data. Setup: https://github.com/komako-workshop/stringers (the user logs in at stringers.io → "配置 agent" to get a personal URL). Site index: https://stringers.io/llms.txt

> The founder posted three X posts each carrying one number (3x faster, LFM3 at 620 tok/s, Qwenputer 23x faster). Two of them rode other people's new model launches, plus a complexity-theory paper for backing and AI newsletter reposts, and each post was followed by a jump in stars.

[GitHub open-source project](https://stringers.io/en/github/index.md) · written 11-6

Generated-Computers/Locals · Generated-Computers

# Three posts, three numbers, 1000+ stars: how Locals squeezed into the most crowded niche

**What it is** A service that runs a small model locally on a Mac for coding agents like OpenCode and Claude Code. It's tuned for several agents sending requests at once, with tool calls that don't break.

**Why it took off** The founder posted three tweets, each with a number (3x faster, LFM3 at 620 tok/s, Qwenputer 23x faster). Two of them rode on other people's new model launches. A complexity-theory paper and reposts from AI news accounts added credibility, and each post was followed by a visible jump in stars.

**B** **How you could follow it** Stop building Mac inference servers. Take the same playbook to less crowded ecosystems (AMD/Qualcomm Windows laptops, iPhone, Jetson, WebGPU). On the day each popular small model launches, ship the "only thing that runs it / fastest" support, pin the README, and quote the original post on X with a number in the title.

Grade B: the approach is clear and repeatable, and every model launch opens another window. But the Mac niche is already packed with oMLX, Rapid-MLX and others. Working in a new ecosystem requires real hard skills, like writing kernels and porting new architectures. Without a number you can actually hit, there is no post. Chatter in small circles

Data (updated daily) · Repo created 2026-10-12 · 641 stars · 7 days +198

GitHub · stars

Data 2026-10-17 → 2026-11-08 (23 days, 22 observations). Points before 10-28 come from deeply / archive backfill, not every day has one

Locals is a local model server that only runs on Apple Silicon Macs. Its pitch: run several coding agents at once, up to 3x faster. It got 1,163 stars on GitHub within 25 days of the repo being created (11-06), even though a similar project, oMLX, already had 23k stars. It didn't win on better tech. It won on a posting rhythm anyone can copy: every post carries a number that fits in the headline, and the posts go out while someone else's new model is trending.

### A launch post with a "complexity theory breakthrough" claim

On Oct 21, 2026, a little after 2pm Eastern, the X account @machinestein (real name Arip Asadulaev, GitHub profile says Research Scientist, email from the UAE's MBZUAI) posted:

> Introducing Locals: an Apple Silicon engine that runs local LLMs up to 3x faster.

The post went on to say it can directly replace Ollama, mlx-lm and llama.cpp; that "underneath is a breakthrough in complexity theory"; and that it's open source and usable on GitHub now. It came with a video and a comparison chart. The post got about 1,100 likes and 100k views. Before that, the repo had been created in Oct 12 and had sat between 26 and 33 stars for a week. Two days after the post, it hit 307.

This isn't a big account. It posted only 4 times in 30 days. One post with 1,000 likes brought in more than 270 stars.

### What it is

In one sentence: if you use a coding agent like OpenCode, Claude Code, Cline or Aider on a Mac and don't want to send your code to a cloud model, Locals runs a small model on your machine for those agents. Install with one command, then run `locals code ~/my-project`. It downloads a model of about 3 GB, starts a server in the background and opens OpenCode in your project.

Compared with general-purpose tools like Ollama and mlx-lm, it is built for "agents, not people chatting":

- **Several agents can ask at once without queuing.** The chart at the top of the README is its whole pitch. On the same M2 Pro with the same Qwen3.5-4B model, Apple's official mlx-lm goes from 4 to 8 concurrent requests, and total output stays flat at 87 tokens per second. Locals hits 3.1x that at 160 to 271,8 requests.

- **Tool calls always parse.** Tool-call and JSON-format constraints are computed on the GPU, using about 3 MB of memory per format (the commonly used llguidance needs up to 1.5 GB).

- **Each turn builds on the last.** The conversation history and the agent's system prompt, which can run to thousands of tokens, are saved to disk, so they don't have to be re-read after a restart.

- **Stops small models from going off the rails.** It detects repetition and loops that keep calling the same tool, and cuts them off.

All of these numbers are the author's own measurements. AlphaSignal's write-up also added a line saying "awaiting independent reproduction."

### How the stars came in waves

Matching each day's star count against the author's posts, all three jumps line up:

| Date | Star change | What happened the day or two before |
|---|---|---|
| 10-22 → 10-24 | 33 → 307 | Launch post, about 1,100 likes, 100k views |
| 10-28 → 10-29 | 356 → 426 | Liquid AI 发布 LFM3 当天,作者引用官方帖:「Locals 能跑 LFM3,620 tok/s」,约 800 赞 |
| 10-30 → 11-04 | +2 to +10 per day | No posts, plateau |
| 11-04 → 11-05 | 451 → 676 | The author posted "Qwenputer now 23x faster," about 600 likes |
| 11-05 → 11-06 | 676 → 1,163 | The AI news account AlphaSignal 11-05 published a write-up, and shiplog, a Korean site and a Korean YouTube explainer video all picked it up |

(Star counts come from GitHub daily snapshots. Checking live in the afternoon of 11-06 showed 1,266. The +487 on the last day came mainly from AlphaSignal or other reposts. There is no per-star timing data, so this is **unverified** .)

The two middle jumps used the same move: **as soon as someone else's new model caught fire, ship "the only / fastest Mac support" for it, put it in a "New:" block at the top of the README, then quote the official post on X.**

- LFM3 is a new 1 GB small model from Liquid AI. The README said "no mlx-lm version can load it yet," so Locals wrote its own implementation. At 8 concurrent requests it gets 620 tok/s, 2.99x mlx-lm.

- Qwenputer was someone else's viral project: it compiled a RISC-V CPU into the weights of Qwen3.5-4B so the model could "compute" a calculator tool itself. The original post got 880k views and was reposted by Qwen's official account. A week after it went viral, Locals moved that "computer inside the model" onto a Mac CPU, written in C, and claimed a 23x speedup (3,300 vs 142 per second). The post was titled "We just achieved a 23x speedup on Qwenputer."

There's one more layer. In Oct 6 the author posted an arXiv paper claiming to lower the fifty-year-old space upper bound from Savitch's theorem, and turned the construction in the proof into an inference engine. Ordinary users can't follow the math, but "complexity theory breakthrough + open-source implementation" gave researchers a reason to share it, and it separated the project from "yet another Mac inference server." Whether peers accept the paper's conclusions is **unverified** .

It didn't take off on Hacker News, and I found no sign of paid promotion or star-buying.

### Lots of followers, few users

The `locals` package on PyPI was downloaded about 700 times from Oct 21 to Nov 5, and 142 times in the last week (pypistats). Many people install through the official `install.sh` or straight from GitHub, so that undercounts real use. Still, 1,000+ stars against a few hundred downloads means far more people starred it than actually installed it. Stars are a result of promotion, not of use.

The project isn't meant to make money either. The official site also has /business (multi-agent inference on enterprise GPUs, claiming "2x faster than vLLM at half the cost") and /horizon (world models). Here the open-source project is a way to build visibility for the company. The organization was only created in Oct 9, and it looks like just one or two people run it.

### Who it's competing with

This niche is already crowded, and nearly every project claims "2 to 4x faster than X, built for coding agents":

| Project | Stars | Relationship to Locals |
|---|---|---|
| Ollama | 186k | The default; since March this year it has also run on MLX on Apple Silicon, but targets single-request chat |
| exo | 48k | Pools several devices into a cluster; a different direction |
| oMLX | 23.4k | The closest rival: since February it has been doing continuous batching, KV cache on SSD, and built for coding agents, plus a menu bar app, 8 months earlier |
| mlx-lm | 7,600 | Apple's official baseline. Locals benchmarks against it and was rewritten on top of it |
| Rapid-MLX | 4,100 | Also claims 2 to 3x speedups and reliable tool calls; shipped 10-29 1.0 |
| mlx-serve, vllm-mlx, vllm-metal | 1,600 to 2,400 | A native Zig server, and vLLM's Mac port |

New projects in this category keep coming: Strim (launched on HN 10-30, 1 points) and Atomic Local AI Server (11-05, on the same day as the Locals wave). Ordinary users can't tell Locals apart from oMLX or Rapid-MLX. **The technical differences are believable, but the numbers and the timing of the posts are what drove the stars.**

### If it were you

**One-line verdict:** Don't build yet another Mac inference server. What's worth learning is the posting playbook, applied to an ecosystem that isn't crowded yet.

**Who it's for:** People who can write GPU kernels, or at least port a new model architecture into an inference framework. Someone with a machine that can run benchmarks, who is willing to stay up all night the day someone else ships a model.

**Who it's not for:** Developers who only call APIs. The playbook depends on "working on launch day, and actually faster." The numbers have to be measured yourself, and without them there is no post. It's also a poor fit for anyone who wants to make money from the project directly. The payoff here is stars, followers and a track record.

**How to do it:**

- Pick a scenario where the official tool doesn't scale and yours does, and turn it into one chart. Locals' chart shows mlx-lm stuck at 87 tok/s from 4 to 8 concurrent requests, while its own version reaches 271. One chart spreads better than a full benchmark table.

- Changing the ecosystem matters more than changing the name: AMD or Qualcomm Windows laptops, running agents locally on iPhone or iPad, Nvidia Jetson, or WebGPU in the browser. The Mac side is already held by oMLX with over 20k stars.

- Watch model launches. When Liquid, Qwen, various small models, or research toys that "compile strange things into weights" start trending, ship "the only / fastest way to run it on your platform," pin a "New:" note to the README, quote the original post on X, and put a number in the title.

- Publish a paper, a technical blog post, or a benchmark others can reproduce. That's more credible than an unsupported "3x faster."

**How to get attention (stars):** The main channel is your own X posts, each with a number, quoting popular original posts to borrow their reach. The second is getting AI news accounts like AlphaSignal to write about it, which works if you hand them a number they can use as a headline. The third is r/LocalLLaMA and r/LocalLLM. Hacker News usually reacts poorly to this kind of project, so don't count on it.

**When the window is open:** The window follows model launches and lasts only one or two weeks after each. Each post makes a wave, and without posts there's a plateau, when Locals went from 10-30 to 11-04 gaining only a few stars a day.

**Signs you've misread it:** You've posted about two or three trending models and each got only a few dozen likes with no star jump. Or the mainstream tools (Ollama, oMLX, llama.cpp) start shipping support on launch day, so "the only thing that runs it" no longer holds. Or your numbers can't be reproduced or get publicly challenged, and a project like this loses its reputation after one incident.

[GitHub repo ↗](https://github.com/Generated-Computers/Locals)

**Research notes: competitor table, acquisition evidence, full research report**

Competitors

| Name | Where | Launched | Scale | How it differs from this one |
|---|---|---|---|---|
| oMLX | Open source | 2026-02 | 23.4k stars | Also does continuous batching and KV-cache-on-SSD for coding agents, and it came out 8 months earlier with a menu bar GUI. Locals adds GPU-side grammar constraints, agent guardrails and multi-agent orchestration commands. |
| Rapid-MLX | Open source | 2026-02 | 4.1k stars, 10-29 posted 1.0 | Also claims 2~3x faster, built for coding agents, with reliable tool calls. Locals pushes multi-agent concurrency, backed by a paper. |
| mlx-lm | Open source | 2025-03 | 7.6k stars, Apple official | Official baseline: throughput stops rising at 4 to 8 concurrent streams. Locals rewrites batching and kernels on top of it. |
| Ollama (MLX backend) | Open source | 2023; Apple Silicon has run on MLX since 2026-03 | 186k stars | The default pick, built for chat and single requests. When several agents ask at once, time to first token is 42 s vs Locals' 1.6 s (author's own test). |
| mlx-serve | Open source | 2026-02 | 2.4k star | Native server written in Zig, with no multi-agent orchestration or grammar constraints |
| vllm-mlx / vllm-metal | Open source | 2025-12 | 1.6k / 2.0k star | vLLM ported to Mac, also with continuous batching. No agent-focused tool-call constraints or guardrails. |
| LM Studio | Other | 2024 | Large desktop app user base; mlx-engine has 1.2k stars | Mainly a GUI and model marketplace, not designed for multi-agent concurrency |
| exo | Open source | 2024 | 48k stars | Chains multiple devices into a cluster to run large models. Different direction. |

Where users come from

- **Verified** **founder's X posts** : 10-22 launch post ❤1123 / 104k views, +274 stars the next day; 10-28 LFM3 post ❤804, +70 the next day; 11-05 Qwenputer post ❤626, +712 over the following two days

- **Verified** **riding new model launches** : Liquid AI released LFM3, and the same day Locals shipped "the only engine that runs LFM3" and quoted the official post. After Qwenputer (original post 885k views, reshared by @QwenDevs) went viral, it shipped a 23x speedup version. README pinned a New: section.

- **Verified** **arXiv paper as backing** : arXiv 2610.09139 (10-06) claims to lower the Savitch space upper bound and turns the proof's construction into an inference engine. The author's paper post ❤142.

- Inferred: **AI news letters and aggregator sites** : AlphaSignal posted it 11-05, with reposts on shiplog, hermes-ai, nav-ai, productradar and hdatf (Korean), plus a Korean YouTube video; whether 11-06 gaining +487 in a single day came mainly from these is unverified

- Inferred **Reddit r/LocalLLM** : the author posted "I just open sourced an Apple Silicon engine…". The page was blocked by 403, so the engagement is unverified.

- **Verified** **Chinese X reposting accounts** : @dsoch8c(10-22), @qikamatata(11-05). Engagement is very small.

## Generated-Computers/Locals: why it works

> In one sentence: Locals is a local inference server that runs only on Apple Silicon Macs, built for several coding agents at once. It does concurrent batching, runs tool-call grammar constraints on the GPU, and keeps the KV cache across turns and restarts. In the author's own test at 8 concurrent streams it is about 3x faster than mlx-lm. Behind it is a newly founded "research lab", Generated Computers, whose founder Arip Asadulaev is an RL/optimal transport researcher. Verdict: the stars were driven by **the founder's own X posts** , each with a number that fits in a headline (3x, 23x), and twice they rode other people's new-model launches (Liquid's LFM3 the day it launched, and Qwenputer a week after it went viral). Add an arXiv complexity-theory paper as "hardcore" backing, and AI news accounts like AlphaSignal picked it up. Real usage is small: total PyPI downloads under 1000.

Data as of: 2026-11-06. Sources: our github / x / hackernews libraries, GitHub API, live X search (TikHub), Jina / Exa web search, pypistats.

### 1. Basic data

| items | value | Source |
|---|---|---|
| Organization created | 2026-10-09 (GitHub org Generated-Computers, location listed as "United States of America") | GitHub API |
| Repo created | 2026-10-12 | GitHub API |
| star | Data card 1163 (11-06 snapshot); live check 1266 | github repo / GitHub API 11-06 |
| fork | 40, fork/star ratio about 3.4% | Same as above |
| Contributors | machinestein (Arip Asadulaev) 197 commits, agafonovartem 27 commits | GitHub API |
| PyPI `locals` downloads | 10-21 to 11-05 cumulative about 700 (peak 10-21/22 each about 200,11-04, which is 92); last week 142 | pypistats |
| License | Apache-2.0 | README |

Daily stars (github repo_day) and matching events:

| Date | Gained that day | What happened around the day before |
|---|---|---|
| 10-17~10-22 | 26→33 | Not formally launched yet |
| 10-24 | +274 (in two days) | **10-22 02:44 (Beijing time) @machinestein launch post "Introducing Locals"** : ❤1123, 👁104k |
| 10-26 | +33 | Picked up by Chinese reposting accounts (@dsoch8c 10-22), nav-ai.net, productradar and others |
| 10-29 | +70 | **10-28 @machinestein post "LFM3 620 tok/s, Flint 319 tok/s", quoting Liquid AI's LFM3 launch post** : ❤804, 👁49k. The same day also an arXiv paper post (❤142). |
| 10-30~11-04 | Daily +2~10 | Plateau |
| 11-05 | +225 | **11-05 01:35 @machinestein post "Qwenputer 23x faster"** : ❤626, 👁27k. Qwenputer was someone else's viral project (@divagr1925 original post ❤6111, 👁885k; @QwenDevs official repost ❤3919). |
| 11-06 | +487 | AlphaSignal ran a write-up on 11-05, "Generated Computers' Locals Triples AI Agent Throughput on Apple Silicon", and shiplog.news, hermes-ai.net and others reposted it. There is also a Korean YouTube explainer and a Korean page on hdatf.com. |

The largest single-day gain was +487 on 11-06. The most likely source is the AlphaSignal coverage and the reposts it triggered, but we cannot get stargazer timestamps (the GitHub stargazers endpoint returns 404 for this repo), so **this is unverified** .

### 2. Competitors

The Mac local-inference lane is already crowded. Nearly everyone claims "2~4x faster than X" and "built for coding agents".

| Product | Form | Launched | Scale | How Locals differs |
|---|---|---|---|---|
| Ollama (default on Apple Silicon with MLX since 2026-03) | open source / desktop | 2023 | 186k stars | The default pick, mainly for chat and single requests. Locals' comparison: time to first token with 8 agents asking at once is 42 s vs 1.6 s. |
| mlx-lm (Apple official) | Open source | 2025-03 | 7.6k star | Official baseline: throughput stops rising at 4 to 8 concurrent streams (87 tok/s). Locals rewrites batching and kernels on top of it. |
| oMLX(jundot) | Open source + menu bar app | 2026-02 | 23.4k stars | The closest rival: it also does continuous batching and stores the KV cache on SSD, targeting the same re-prefill problem coding agents hit every turn. It shipped 8 months earlier and has a GUI. Locals adds GPU-side grammar constraints and orchestration commands `locals run` / `locals code`. |
| Rapid-MLX | Open source (OpenAI/Anthropic compatible) | 2026-02 | 4.1k stars; 10-29 launched 1.0, with a built-in agent | Also claims "2~3x faster than others, built for coding agents, with reliable tool calls". Locals pushes multi-agent concurrency, backed by a paper. |
| mlx-serve(Zig) | Open source | 2026-02 | 2.4k stars, +222 over the last 7 days | Native, non-Python server, with no multi-agent orchestration |
| vllm-mlx / vllm-metal | Open source | 2025-12 | 1.6k / 2.0k star | vLLM ported to Mac, also with continuous batching. Locals' angle is tool calls and agent guardrails. |
| LM Studio(mlx-engine) | Desktop apps | 2024 | mlx-engine has 1.2k stars, with a large app user base | Mainly a GUI and model marketplace, not designed for multi-agent concurrency |
| exo | Open source | 2024 | 48k stars | Chains multiple devices into a cluster to run large models. Different direction. |
| Atomic Local AI Server | Desktop / server | 2026-11-05 | Launch post ❤207 | One shell that wraps several inference engines. It launched the same day as Locals and competes for the same attention. |
| Strim | Open source (Swift/MLX) | 2026-10-30 Show HN | 1 ratings | Also pitched as a "Mac model server for coding agents", with almost no buzz. |

Verdict: **Plenty of competitors, and oMLX has already taken the spot for "inference server for agents on Mac" (23k stars)** . Locals didn't open a new category; it squeezed into a crowded one with a better story.

### 3. Where users came from (growth tactics)

1. **The founder's X posts, one headline number each** (confirmed): launch post ❤1123 / 104k views, and every later star jump lines up with a post from the day before. @machinestein is not a big account (only 4 posts in 30 days), yet one post with 1000 likes brought in about 270 stars.

2. **Newsjacking new model launches** (confirmed):
    - The day Liquid AI launched LFM3, Locals shipped support for "the only way to run LFM3" (the README says "No mlx-lm release can load it yet") and quoted the official post → ❤804;
    - After Qwenputer (someone compiled a RISC-V CPU into Qwen weights; original post 880k views, retweeted by Qwen officially) went viral for a week, Locals ran it on CPU in C and claimed a 23x speedup → ❤626, then +700 stars over the next two days;
    - Recursive's Flint (40B MoE) got the same treatment. The playbook: as soon as a new model or trick takes off, ship "fastest / only way on Mac" support, put it in a "New:" block pinned at the top of the README, and quote the original post.

3. **Paper backing** (confirmed): arXiv 2610.09139 (2026-10-06 submissions) claims to lower the Savitch theorem's space upper bound for the first time in 50 years, and the construction from the proof was turned into an inference engine. The "complexity theory breakthrough + engineering delivery" story travels well; @DimitrisPapail (a core member of the AI research crowd) also reposted Qwenputer.

4. **AI newsletters and aggregator reposts** (confirmed present; their traffic contribution to the 11-06 wave is unverified): AlphaSignal (11-05), shiplog, hermes-ai, nav-ai, productradar, hdatf (Korean), a Korean YouTube video, and Chinese X repost accounts (@dsoch8c, @qikamatata).

5. **Organic Reddit r/LocalLLM post** (existence confirmed; post date and engagement unverified, the page was blocked by 403): "I just open sourced an Apple Silicon engine…"

6. **HN** : no Locals Show HN found in the database (our bar is ≥5 points), so it didn't take off on HN.

7. No evidence of paid acquisition or star farming. The fork ratio of 3.4% is on the low side, but the README tells people to use `uv tool install`, so users don't need to fork; the repo is not flagged as suspect.

### 4. Why it took off

- **Timing** : in 2026, local coding agents (OpenCode, Claude Code wired to local models, OpenClaw/Hermes) and small agent models (Qwen3.5-4B, LFM3, Flint) matured at the same time. "Running several agents in parallel on a Mac" became a real need, while mlx-lm stopped getting faster past 4~8 concurrent paths. That weakness is exactly what Locals' chart made visible.

- **Sharp narrative** : one chart, one number (87 → 271 tok/s, 3.1x), one line ("Run many AI agents at once on your Mac"), benchmarked against the well-known mlx-lm and Ollama.

- **Research credibility** : an arXiv paper, a big phrase like "breaking the Savitch bound", which gives it buzz among researchers and separates it from a generic "yet another MLX server".

- **Repeatedly riding hot topics** : whenever growth plateaued, it rode the next hot model to push again. All three star jumps came this way.

- **Low barrier to entry** : `locals code ~/my-project` is one command that downloads the model, starts the server, and opens OpenCode; `locals launch` is one command to hook into Claude Code, Cline, Aider and other tools.

### 5. Differentiation, and whether it's really why it grew

Technical differentiation: (1) grammar constraints (tool calls, JSON schema) are computed on the GPU, with no lookup table, and one grammar takes only 3 MB (llguidance needs up to 1.5 GB), so 16 tool schemas can be loaded at once; (2) GPU kernels rewritten for small batches, getting faster as concurrency rises; (3) guardrails built for agents: stopping repetition loops, stopping repeated calls to the same tool, memory protection; (4) `locals run` splits a task, runs it in parallel across several project copies, and lets the tests decide which result wins.

**These differentiators only function as credibility in the spread, not as the direct cause of growth.** Ordinary users can't tell it apart from oMLX or Rapid-MLX, and all the benchmarks are the author's own (AlphaSignal also wrote "await independent reproduction"). What actually drove stars was numbers like "3x / 23x", the paper narrative, and timing other people's model launches well. PyPI shows only a few hundred downloads, meaning far more people are watching than have actually installed it.

### 6. Visibility and copycats

- Revenue: none, it's open source and free. The monetization directions are on the website at /business (a multi-agent inference engine on GPU, claimed as "2x vLLM, half the cost") and /horizon ("a world model like a whole computer"). It's a classic case of using an open source project for visibility and paving the way for enterprise business or fundraising.

- Visibility: **circulating in small circles** . Only AI newsletters (AlphaSignal etc.) and Chinese and Korean repost accounts covered it; no mainstream tech media coverage, no big-name voice specifically recommending Locals itself (Dimitris Papailiopoulos reposted Qwenputer's post); it didn't take off on HN.

- Copycats: none directly copying Locals. Similarly positioned new projects are already appearing (Strim 10-30, Atomic Local AI Server 11-05), but this looks more like a crowded category than imitation of Locals.

### 7. What others can learn

- The growth playbook for open source infrastructure projects: **watch new model launches and ship "fastest / only way on Mac" support the same day** , pin it in a "New:" block at the top of the README, and quote the official post on X. Each time you do it, it's a free traffic wave.

- A single comparison chart that shows "where it fails and where I win" (mlx-lm throughput stays flat past 4→8 paths) spreads better than a whole table of benchmarks.

- Paper + open source + one-command onboarding, all three at once, so both the researcher crowd and the developer crowd can take it in.

- Name and tagline describe results users can feel ("run many agents, 3x faster") instead of technical jargon.

### 8. Uncertain

- Where the 11-06 wave's +487 actually came from (AlphaSignal, Reddit, or another big account's repost) can't be determined without stargazer timestamps; unverified.

- The 3x / 23x figures are the author's own measurements with no third-party reproduction; whether peers accept the paper's complexity claim is unverified.

- Real usage: PyPI downloads are low, but many people may install via `install.sh` or uv from GitHub, and that part of the count is unknown.

- Whether the company has raised funding or how big the team is is unknown (it looks like 1~2 individuals).

This article was written by AI from public data and the data we collect daily. Numbers are sourced, and inferences are labeled.