Wujie Fangzhou releases Edge0-145B and inference engine to explore local laptop use

The team reports sparse architecture, tiered storage and hardware-specific memory and speed tests, with coding and 3D demos. Performance depends on hardware, context and tools.
Editorial correction (November 16, 2026): Some configurations in the original article differed from the current official model card and have been corrected for the relevant versions and test conditions. 29GB is not the total resource requirement for an arbitrary computer, and offline inference does not mean zero total cost or automatic compliance. Model weights are separately subject to Edge0 and upstream community licensing terms, and some commercial services require additional authorization. Open-source framework code must not be equated with unrestricted commercial use of the weights. Reference: https://huggingface.co/Edge0/Edge0-145B-NVFP4

An on-device model at the hundred-billion-parameter scale that can do Vibe Coding.
In 2024, before Apple had officially announced Apple Intelligence, speculation about which model company would become Apple's AI partner in China briefly became an unofficial ranking of Chinese large-model developers. Baidu, Alibaba, Tencent and ByteDance were all mentioned in turn. In February 2025, after confirming its involvement in the partnership, Alibaba saw its Hong Kong-listed shares rise as much as 9.2% intraday.
Before AI had truly arrived on devices, the market had already written it a new “Make Mobile Phone Great Again” script.
It was not until late October 2026 that Apple finally announced the launch arrangements for the mainland China version. The upgraded assistant that could understand complex requests and carry out errands for users—the next-generation Siri AI—remained a distant prospect. The first batch of writing, translation and photo-processing features also did not go beyond the scope of traditional on-device AI.
With large models already permeating every aspect of work and life, why had Apple delayed again?
The memory wall is an unavoidable part of the answer.
A running model needs access to its weights, but not all parameters have to remain resident in the same memory tier at all times. Quantization, sparse computation and tiered storage affect requirements for system memory, GPU memory, disk space and bandwidth.
This is why, even as cloud models advance by leaps and bounds, on-device models remain caught in an “impossible triangle” of intelligence, memory and I/O, repeatedly trading one against another.
An on-device model seeking high intelligence without keeping its weights resident and occupying memory needs sparse activation and on-demand loading. The price is continuous consumption of I/O bandwidth: even a very simple question may take minutes to answer.
On-device deployment requires trade-offs among model capability, storage, memory, bandwidth and latency. The choices depend on the implementation; this description does not establish that the intelligence ceiling of small models is fixed.
But has the ceiling for on-device models really been fixed?
A company called Wujie Fangzhou offers a new way to approach the problem.
At the hundred-billion-parameter scale,
exploring local operation at the hundred-billion-parameter scale
The team previously released Edge0-35B, exploring sparse activation and on-demand loading to reduce active memory requirements. There is not enough evidence here to call it an industry first.
According to official test data, Edge0-35B has peak runtime memory usage of around 2.5GB and generates more than 37 tokens per second on supported phones.
In other words, the model still has 35 billion parameters, but only the portion that can be activated quickly needs to remain in memory on the device at any given time. The remaining weights sit in device storage, prepared in advance by the inference framework and loaded on demand.
With these results behind it, shortly after Edge0-35B's release, a post surpassed 1.2 million views on its first day without paid promotion in overseas communities. Technical experts and researchers from OpenAI, NVIDIA, Qualcomm and other companies shared it, and the model then reached No. 1 on Hugging Face's site-wide Trending list.
Licenses for model weights and the inference framework must be checked separately. Current Edge0 models are governed by community licenses and upstream terms. Commercial bundling, model services, and standalone commercial coding or office assistants require separate written authorization; the framework code's open-source license does not automatically cover these uses.
If the old assumption was that phones could hold only small models, Edge0-35B asks a different question: could a phone hold only the part of a large model it currently needs, while keeping the wait short enough?
Following this path, Wujie Fangzhou has pushed on-device model size into the hundred-billion range with 145B. Today, Edge0-145B's weights are available on Hugging Face, and its new unified on-device inference engine is open source on GitHub, with one-click deployment tools and a complete hardware-adaptation guide. The model can handle writing code, operating software, building 3D scenes, and repeatedly planning, executing and revising toward a goal—complex tasks that previously relied mainly on cloud models.
Current official documentation distinguishes platforms and formats: Q3_K provides a Metal path for Apple Silicon macOS, while NVFP4 is a CUDA build. Linux and Windows support also depends on the corresponding hardware and build. A platform list must not be read as meaning every computer can run it directly.

The illustration presents the team's account of changes in on-device model size and capability. It is insufficient to establish that this is the first hundred-billion-parameter model that can run locally.
This release explores local-model deployment and task capabilities. The listed performance must be understood in terms of the specific weight format, hardware and workload, and cannot establish that on-device models have, for the first time, matched cloud models overall.
- System memory and GPU memory must be accounted for separately. The current official NVFP4 example uses around 23.25 GiB of GPU memory and 38.27 GiB of host memory on an RTX 5090 D with residency enabled. The original 29GB figure is not a total-resource guarantee across platforms.
- Prefill throughput does not mean the first token appears instantly. Input length, model loading, caching, hardware and scheduling jointly affect the wait.
- Decoding speed must be limited to the tested hardware, quantization format and context conditions. It does not guarantee 80 tokens per second on every personal laptop.
- Power consumption, heat dissipation and throttling during extended operation depend on the device and workload. One typical power figure cannot provide a universal guarantee.
- The model card lists long-context configurations, but long inputs change caching, memory access and execution costs. Speed is not guaranteed to remain unchanged on long tasks.

Throughput and memory figures for different model variants and hardware cannot be compared directly. Check resource requirements against the target format, device and task; the original phone and laptop figures are not a comparison under identical conditions.
Hundred-billion-parameter models:
from usable on devices to pleasant to use
Once the question of whether it can run is resolved, a new question follows.
Even if a hundred-billion-parameter model can load locally, will users actually want to use it?
Starting the model is only the first step. After feeding in dozens of pages of code, how long must you wait before the answer begins? Can generation keep up with reading? If a task runs for half an hour, will heat slow the device down? While the model is running, can other software still work normally?
These questions directly affect the actual user experience.
Wujie Fangzhou's answer is to adjust the model structure, weight storage and compute scheduling together.
The current official version is described as a latent sparse MoE with routed experts, shared components, embeddings and other parts, listing 145B total parameters and around 10.12B active per token. Architecture and parameter counts must be checked for the specific version; the original 6.6B figure cannot be carried forward as the current universal configuration.
Once the architecture is set, model training is tailored to both that architecture and on-device requirements.
The next challenge is loading. A sparse architecture reduces computation but does not automatically solve where weights are stored or how to retrieve them promptly when needed. Even an expert that is temporarily unused still has parameters occupying storage somewhere.
Edge0-145B assigns different roles to different storage tiers: frequently used parts are kept in faster GPU memory wherever possible, while the rest is distributed between system memory and SSDs. As the model computes, the system prepares data needed next, minimizing the idle gaps spent waiting for another batch of weights after a computation step.
The final step is scheduling: make the CPU and GPU work together, then use speculative decoding to propose and verify several candidate tokens at once, spreading some computation and read overhead across more outputs.

With these optimizations, loading a hundred-billion-parameter model onto an on-device system and running it smoothly and efficiently is no longer difficult. The next question is just how much this model can do.
From being able to chat to being able to work
If deploying a hundred-billion-parameter model on a device only enables offline chat, it is little more than a display of technical muscle. The real goal is to complete complex tasks independently.
Across six mainstream evaluations published by Wujie Fangzhou, Edge0-145B scores 64.6 on DeepSWE 1.1, 86.5 on Terminal-Bench 2.1, 35.4 on HLE, 90.4 on GPQA-Diamond, 80.6 on IFBench and 79.3 on AA-LCR. Its overall level falls in the same tier as mainstream open cloud models such as DeepSeek-V4-Flash. Its strengths are agents and coding. On the two agentic coding evaluations, DeepSWE and Terminal-Bench, Edge0-145B exceeds open models in the same tier. On Terminal-Bench 2.1, IFBench and AA-LCR, it also scores higher than the closed cloud model Claude Opus 4.6 (Max).

The illustration compares the listed evaluation configurations. Individual scores cannot establish that on-device models have, for the first time, reached the overall capabilities of top cloud models.
Compared with mainstream on-device models in the tens-of-billions-of-parameters range, Edge0-145B improves most clearly on agent and coding tasks: 18.5% on Terminal-Bench and 53.1% on DeepSWE. It also improves by 1%–15% on reasoning and knowledge tasks, including HLE +14.9%, GPQA +1.3% and IFBench +1.4%. Complete test settings, hardware environments and reproduction instructions are published with the technical report.

Local operation also requires accounting for GPU memory, host memory, disk space for weights and caches. A laptop with 48GB cannot be treated as an unconditional deployment guarantee.
But benchmarks are only slices of capability. The real world requires a model to get things done.
Vibe Coding is a touchstone for testing a model's actual level. With Edge0-145B, a user gives just one natural-language instruction and the model completes the whole workflow locally: first break down the requirements and plan steps, then write code and call tools to run it, debug and repair errors itself, and finally take screenshots to check the visual results. If it is unsatisfied, it keeps revising until it delivers a complete, usable creation. The process often involves dozens of rounds of planning, execution and self-checking, precisely the kind of long-chain agentic task that previously only cloud models could handle.
A local model can reduce cloud inference calls, but whether tools, research, assets and external services use the internet depends on the actual configuration. The entire task is not guaranteed to work offline, nor is all data guaranteed to remain on the device.
For example, here is a request for Edge0-145B to generate a video explaining the Roadster, telling a general audience why a car can fly. In this task, Edge0-145B can independently research the technical principles, write the script, generate assets and edit them creatively. No cloud calls, no cloud token consumption and no network latency.
Local inference can reduce cloud-service fees charged per token, but devices, energy, storage, tools and human review still cost money. Demonstration runtimes cannot replace a like-for-like cost comparison with professionally finished work.

The same capabilities are also used in creating three-dimensional scenes.
For 3D creation, Edge0-145B can operate Blender, build scenes from text and reference images, adjust materials and lighting, and keep iterating based on render results. We asked it to model Manhattan. It sees more than pixels: it can understand objects, spatial relationships and creative goals. Previously, a human had to inspect the image, write code and make changes in a fragmented workflow. Now the model handles all three steps directly in Blender and renders the result, staying local throughout.

This 3D demonstration does not establish equal quality, scope or delivery responsibility compared with human-produced finished work. Local operation reduces some cloud-call costs; it does not mean the total cost of 3D production is zero.
Building on 3D modeling, Edge0-145B can also create an entire world for a game. We gave it a request at the level of a game trailer: build an original medieval main city for a fantasy RPG and render a 20-second flyover. Edge0-145B planned the overall design autonomously and built the city walls, more than a thousand old-town homes, a plaza fountain, a Gothic twin-tower facade, a rib-vaulted nave and stained-glass windows from scratch in Blender, then rendered the scene along a fixed camera route. In scenes like these, any mesh intersection, occlusion or disproportion is fully exposed on camera. But the model can inspect rendered frames and correct itself as it models, staying local throughout.
Cost comparisons should also disclose conditions such as model version, output quality, tool-call counts and cache counts. The original article does not provide enough material to independently recalculate all costs, so it cannot guarantee zero cost or a fixed saving for all similar projects.

This workflow can extend to hardware development too.
In the drone example, the team asked the model to “write a drone program that navigates obstacles and finds a red backpack.” After the model generated flight-control and visual-recognition programs, we saw the drone move through obstacles indoors and locate the target.

Beyond video, 3D modeling and games, we also tested a harder task: entering a hardware engineer's workspace to design a PCB from scratch. In this example, the model needs to understand and use two kinds of software at once: first complete component placement and two-layer routing in KiCad, then import the board into Unreal Engine 5, set cameras and lighting, and generate an animation presenting the manufacturing and assembly process.

Local deployment can reduce data transfers, but tool networking, logs, permissions, dependencies and data-processing workflows still need to be checked. Confidentiality or compliance is not automatic.
Why Wujie Fangzhou?
On-device models are not a new field. Several overseas Neo Labs valued at tens of billions of yuan are already working on them, producing many papers, yet very few on-device models genuinely run on consumer hardware.
On-device deployment requires a model company to deliver more than a set of weights. It must also answer: under what configuration does the model run, how much memory does it use, how does it coexist with other system tasks, and how can hardware vendors integrate it into their products?
These are precisely Wujie Fangzhou's strengths:
First, a complete model product lineup. Over the past year, Wujie Fangzhou has released four model families and 200 models that can divide work and collaborate like a human brain. The Audio8 speech model handles listening and speaking; the Decision0 decision model handles fast thinking, making a judgment in around 40 milliseconds; the Edge0 on-device large model handles complex agent tasks and Vibe Coding; and the Embedding0 vector model handles memory. With parameter counts ranging from tens of millions through tens of billions to the hundred-billion scale, they keep pushing the intelligence ceiling of on-device AI upward.

Second, a full-stack approach. Wujie Fangzhou pursues full-stack on-device AI R&D, centered on jointly optimizing models, inference frameworks and hardware chips. It therefore develops both on-device models and on-device inference frameworks, optimizing models for hardware characteristics from the training stage while also changing the inference engine so models run efficiently on different chips.
Third, an industry flywheel. The on-device market is highly fragmented. Chips have different NPU architectures and varying support for numeric formats such as INT4, INT8 and FP4, so directly deploying a general model makes it difficult to exploit the hardware's performance. Wujie Fangzhou tackles each chip individually. It currently supports 95% of mainstream chip platforms, including Qualcomm, Hengxuan, Rockchip, Allwinner, Digua and Nvidia, across headphones, glasses, phones, PCs, robots and other hardware forms. Every chip adaptation, model deployment and product implementation creates reusable optimization capabilities, making the next deployment faster and more economical.
So far, downloads of Wujie Fangzhou's publicly released models have exceeded 15 million within three months, and they have repeatedly topped Hugging Face's overall Trending list. As of October 2026, the company had more than 110,000 customers.
Epilogue
Looking further ahead, changes in on-device model capabilities may also affect the positioning of cloud models.
Previously, the division between device and cloud was often determined by capability: devices handled wake-up, recognition and simple commands, while complex requests went to the cloud. Users seeking smarter AI usually had to accept connectivity, waiting and recurring invocation fees.
As devices begin handling more complex tasks, the conditions underlying this default division are gradually loosening.
The first changes may come in frequent, relatively well-defined requests closely tied to the device itself.
Cost is the first consideration behind these choices.
With a cloud-only approach, every device sold may bring an ongoing stream of inference expenses. The more active the user, the higher the service cost. Hardware margins are low, and a business model relying on long-term SaaS fees may not be viable in the short term in China, where people even borrow subscriptions to watch television dramas. Returning suitable tasks to the device can reduce these recurring expenses and make service costs easier to predict.
Second is data compliance. As AI starts reading codebases, orders, financial reports, customer information and hardware-design files, businesses care not just about answer quality but about what data must leave their devices. Local inference allows some tasks to be completed where the data reside, reducing the need for uploading and remote processing. For workflows that have delayed adopting AI because of sensitive materials, this may be an easier entry point.
Another kind of change occurs where networks are unreliable. If a device must be online to understand its user, its capabilities are always constrained by network conditions. This is especially true for headphones, glasses and robots: poor signal does not lower users' expectations of immediate feedback. Stronger on-device capabilities let the device retain more functions under weak connectivity or no connection.
The needs around cost, data and networks have always existed. Previously, users often had to make concessions among them to obtain stronger model capabilities. Now that on-device intelligence is improving, users really do have more choices.
But this does not mean every task should move back to local execution.
In Wujie Fangzhou's view, breakthroughs in on-device intelligence have already shifted the boundary between device and cloud three times.
Before September 2026, the cloud was primary and devices secondary. Apple Intelligence represents this stage: privacy was protected, but devices could do little, with the real intelligence remaining in the cloud.
After the open release of Edge0-35B on September 10, 2026, everyday tasks moved to devices while complex tasks went to the cloud. For the first time, on-device models handled frequent, everyday needs requiring immediate responses. For one leading headphone manufacturer, Wujie Fangzhou built a device-cloud collaborative solution in which 92% of AI usage is already handled by on-device models and only 8% by the cloud. Everyday conversation accounts for most demand in wearable consumer hardware.
After the open release of Edge0-145B on November 13, 2026, the boundary will move a step further.

A future in which devices are primary and the cloud plays a supporting role may already be close at hand.
This article comes from the GeekPark WeChat account. Author: GeekPark.
Related topics
After reading
Join the AINRK community
Read how to join the community and connect with people working in AI.




