China Telecom's Xing4.0-29B-A4B: a single-GPU agent model, now available as GGUF

China Telecom AI has released Xing4.0-29B-A4B, an open language model built to work through multi-step tasks and call tools on its own. Thanks to its mixture-of-experts design, it only uses 4 billion parameters per token. bartowski has now published ready-made quantized GGUF files that let it run on a single graphics card.

Model releases Try it yourself Nov 6, 2026 7 min read Source: Reddit r/LocalLLaMA
Illustrative image, AI-generated

What it's about

China Telecom Artificial Intelligence Technology, or TeleAI for short, is the AI research arm of Chinese telecom giant China Telecom. It has released Xing4.0-29B-A4B, a language model the company describes as a "lightweight agentic large model". "Agentic" means the model shouldn't just answer questions. It should break tasks into steps on its own, call external tools, read long documents and deliver a finished result at the end.

The official press release (via GlobeNewswire, picked up by Business Insider and Yahoo Finance, among others) is dated September 22, 2026. The weights are on Hugging Face and GitHub under the name XingChen-AGI. There's now news for people who run models like this at home: the well-known quantizer bartowski has uploaded ready-made GGUF files. GGUF is the file format used by llama.cpp, LM Studio, Ollama and similar programs, so you can run the model locally without converting it yourself.

How the model is built

Xing4.0-29B-A4B is a mixture-of-experts (MoE) model. Instead of using every part of the network for each word, a kind of router picks just a few specialized subnetworks, called experts. As a result, only about 4 billion of the 29 billion parameters are active per token. That's what the "A4B" in the name refers to. A token is a chunk of a word, the unit language models use to process text. The company says this lets the model answer simple requests almost instantly while still drawing on its full capacity for hard tasks.

bartowski's model card lists 31 billion parameters for the source checkpoint. The gap to the official 29 billion probably comes from extra layers. The model includes MTP (multi-token prediction) layers that predict several upcoming tokens at once. They act as a built-in draft model for speculative decoding. A fast helper guesses several words ahead, and the large model checks them in a single pass. When the guesses are right, text comes out much faster. In llama.cpp, you turn this on with the --spec-type draft-mtp parameter.

The context window, the amount of text the model can keep in view at once, is 256,000 tokens. According to Telecoms Tech News, that's enough to handle entire software repositories, extensive technical documentation and dependencies spread across multiple files. The model card says the model only accepts text. It doesn't understand images.

What the company promises

TeleAI highlights one number above all: 75.0 out of 100 on SWE-bench Verified. In this test, a model has to fix real bug reports from open-source projects. That means digging through code across several files, finding the bug and writing a working patch. The company says this puts the model at the top of its size class. It also claims strong results in tests of function calling, long-context retrieval, code generation and correct JSON output. JSON is a structured data format that programs can process directly. The available sources don't give specific numbers for these tests or a full comparison table against competing models.

China Telecom says the model is already in use inside the company. It runs in the group-wide customer service platform, where it handles complex requests with multi-step reasoning and tool calls, and in assistant systems for home devices. The company says this has "significantly" improved the first-contact resolution rate and handling times. It doesn't give hard figures.

"We believe the future of AI lies not in ever-larger models, but in making powerful intelligence accessible, affordable and deployable everywhere," a China Telecom AI spokesperson said.

The company says the model works with the common open-source frameworks for training, inference and agent development, and it has also been tested on Chinese AI chips. Larger models in the Xing4.0 series are due in the coming months.

The GGUF files in detail

bartowski built the files with llama.cpp release b12174, using an imatrix. This technique uses sample text to measure in advance which parts of the model matter most, then stores those parts more precisely during quantization. The calibration text combines ordinary prose with dialogues full of tool calls and reasoning steps, formatted in the model's chat template.

What's new is a model-specific layout. Instead of fixed default rules, the weights this particular model is most sensitive to get extra precision. This was measured with KL divergence, a measure of how far the quantized model's outputs drift from the original. Lower is better.

Quantization KLD new layout KLD standard layout Ratio at equal size
Q4_K_M 0.0353 0.0431 0.99×
Q3_K_M 0.0952 0.1217 1.04×
IQ2_XXS 0.4148 1.1512 0.50×

Once you account for the difference in file size, the new layout barely helps at Q4 and Q3. At the most aggressive compression, IQ2_XXS, it cuts the drift in half.

A selection of the files:

File Size bartowski's verdict
BF16 62.45 GB full precision
Q8_0 33.22 GB extremely high quality, usually unnecessary
Q6_K 27.19 GB near perfect
Q5_K_M 24.00 GB high quality
Q4_K_M 20.06 GB default recommendation
IQ4_XS 17.98 GB decent, smaller than Q4_K_S
IQ3_XXS 14.43 GB lower quality
IQ2_XXS 10.32 GB very low quality

In every file except Q8_0, the MTP layers are stored as Q4_0, because that's fast and increases the speedup from speculative decoding.

What you need to try it

The company says you need only 15 GB of VRAM. That matches the smallest 3-bit variants, such as IQ3_XXS (14.43 GB) or IQ3_XS (14.92 GB). On a 16 GB card, though, that leaves very little room for context. For the recommended Q4_K_M (20.06 GB), you need a graphics card with 24 GB of VRAM, such as an RTX 3090, 4090 or 5090. A smaller card can still work. Because only 4 billion parameters are active per token, an MoE model often stays reasonably fast when some of the experts sit in system RAM. In that case, your VRAM and RAM combined should be a few GB larger than the file. Running on the CPU alone is also possible, and llama.cpp automatically repacks the weights to suit ARM and x86 processors. Macs with Apple Silicon and at least 32 GB of unified memory are a good fit. bartowski notes that Q4_1 is more efficient per watt there. Plan on 15 to 25 GB of disk space for the file. Important: you need llama.cpp release b12174 or later, or a program built on it.

The bigger picture

Xing4.0-29B-A4B enters a crowded field. MoE models with around 30 billion parameters and only a few active ones are the most popular size for running agents on your own machine. The standout is the claimed SWE-bench Verified score of 75. For a model with 4 billion active parameters, that would be very high. It's unclear how it was measured, for example which agent scaffold was used and how many attempts the model got. There are no independent measurements yet, and the reports from Telecoms Tech News and Business Insider mostly repeat the press release. The sources also don't mention the license, so check it on the original page before any commercial use. bartowski's model card found no details on the prompt format. Even so, if you care about privacy and want to run a coding or research agent entirely on your own machine, the model is worth a try.

Sources

#open source#moe#agents#gguf#china telecom#coding
Read the original source

Try it yourself: Xing4.0-29B-A4B

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Xing4.0-29B-A4B is a text model meant mainly as a workhorse for agents. It's designed to break tasks into steps, use tools via function calls, output clean JSON, and write or fix code. With 256,000 tokens of context, it can read very long documents or large parts of a codebase in one go. Because only 4 billion parameters are used per word, it's fast for its size, even when part of it sits in system RAM. The company cites a score of 75 on SWE-bench Verified. That would be top of its class, but it hasn't been independently verified yet. The model doesn't understand images, and the sources don't say how good it is in languages other than English and Chinese. So try it yourself before you rely on it.

Who is it worth it for?

The model is worth it for developers and tinkerers with a 24 GB graphics card or a Mac with plenty of memory who want to run a coding or research agent entirely locally, for example with Pi, Hermes Agent or OpenClaw. If you only chat now and then or have an 8 GB graphics card, you're usually better off with a smaller dense model.

Ideas: What you can do with it

Local coding assistant

Start llama-server with the model and connect an agent tool such as Pi to your project folder. The model reads your code, finds bugs and suggests changes. Your code never leaves your machine.

Analyze long documents

Paste in manuals, contracts or meeting minutes as text and have the model pull out summaries, deadlines or contradictions. Thanks to the large context window, even long texts work, as long as you have enough memory.

Structure messy data

Paste in messy notes, emails or invoice text and have them output as JSON or a table. You can drop the result straight into a spreadsheet or your own scripts.

Everyday scripts

Describe an annoying routine task, such as renaming photos by date or making backups, and have the model write and explain a script for it. Test it on a copy of your files before you use it for real.

Build agent prototypes

Developers can hook up their own tools via function calling through the OpenAI-compatible API, then test workflows such as customer inquiries or ticket sorting locally before moving anything to the cloud.

Size31.2 B parameters (4 billion active)
Download19 GB (about 25 min at 100 Mbit/s)
Licenseapache-2.0
TypeLanguage model (text chat)

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 22 GB VRAMe.g. RTX 3090, RTX 4090, Tesla P40 – fastest; with less VRAM, see the next line
Graphics card + system memory (MoE offloading) from approx. 6 GB VRAM + 32 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar
Mac (Apple Silicon M1–M5) from 32 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
CPU only (no graphics card) Runs smoothly without a graphics cardan estimated 9 words per second on a current desktop PC (MoE: only 4 billion parameters active per word). This requires at least 32 GB of RAM.
Storage approx. 21 GB freeModel download plus programs
Google Colab Colab Pro onlywith MoE offloading on a T4/L4 plus a High-RAM runtime (about 51 GB of RAM); free Colab doesn't have enough RAM

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

VariantDownloadNeeds approx.Compatible graphics cards
Q4_K_M Default 19 GB22 GBe.g. RTX 3090, RTX 4090, Tesla P40
Q5_K_M 22 GB26 GBe.g. RTX 5090
Q6_K 26 GB30 GBe.g. RTX 5090
Q8_0 33 GB38 GBe.g. 2× RTX 3090/4090 or RTX A6000
F16 62 GB70 GBe.g. multiple professional GPUs (2× A6000, H100) or DGX Spark

The default pick is Q4_K_M (20.06 GB) for graphics cards with 24 GB of VRAM. If you have more memory, go for Q5_K_M (24 GB) or Q6_K (27.19 GB) for near-lossless quality. With 16 GB of VRAM, IQ3_XXS (14.43 GB) or IQ3_XS (14.92 GB) will work, roughly matching the company's 15 GB figure, but that leaves little room for context. Alternatively, you can offload part of Q4_K_M to system RAM. Below Q4, bartowski recommends I-quants (IQ…) on Nvidia and AMD cards. On CPUs and Macs, K-quants are faster, and on Apple Silicon Q4_1 is especially efficient. The 2-bit variants starting at 10.3 GB are only a last resort.

  • Q4_K_M is 20.06 GB, so it only fits entirely on graphics cards with 24 GB of VRAM or more.
  • The company says 15 GB of VRAM is enough with heavy quantization. That matches the IQ3 files at around 14.4 to 14.9 GB.
  • Long context needs extra memory: the full 256,000 tokens barely fit alongside the model on regular graphics cards. Start with 16,000 to 32,000 tokens.
  • As an MoE model with 4 billion active parameters, it stays fairly quick even with parts in system RAM or running on the CPU alone. Your VRAM and RAM combined should be 1 to 2 GB larger than the file.
  • llama.cpp automatically repacks the weights for ARM and x86 CPUs, so you don't need special CPU files.
  • According to bartowski, Q4_1 is more efficient per watt on Apple Silicon. Macs with at least 32 GB of unified memory make sense.
How do I find out what my computer has?
  • Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
  • Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
  • Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: Colab Pro only – needs the L4 GPU (22.5 GB); the free T4 is too small.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
  4. Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU (with Colab Pro: L4 or A100) → Save.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 10 minutes here.
  7. Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
  8. Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

  1. Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
  2. Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
  3. Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
  4. Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
    ollama run hf.co/Venastine-Research/Xing4.0-29B-A4B-GGUF:Q4_K_M
    The first time, Ollama downloads the model (19 GB (about 25 min at 100 Mbit/s)). After that, it's instant.
  5. Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/Venastine-Research/Xing4.0-29B-A4B-GGUF:Q4_K_M.

Prefer automatic? A script that picks the right variant for you
  1. Download both files into the same folder: try_windows.ps1 demo.py
  2. Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.
  3. Paste this command and press Enter:
    powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

  1. Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
  2. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  3. Start the model. Paste the command (Cmd + V) and press Enter:
    ollama run hf.co/Venastine-Research/Xing4.0-29B-A4B-GGUF:Q4_K_M
    The first time, the model is downloaded (19 GB (about 25 min at 100 Mbit/s)).
  4. Start typing. Type your question and press Enter. Quit with /bye.
Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
  3. Start the model:
    ollama run hf.co/Venastine-Research/Xing4.0-29B-A4B-GGUF:Q4_K_M
    Exit with /bye. Use ollama ps to check whether the model is running on the GPU.
  4. Or let it pick the right variant automatically:

    try_linux.sh

    bash try_linux.sh
    # mit Python/transformers statt Ollama:
    MODE=hf bash try_linux.sh

Try it

Explain in five sentences what a mixture-of-experts model is.
Return the following contact details as JSON with the fields name, email and phone: Jane Doe, jane@example.com, +1 555 123 4567.
Write a Python script that reads all CSV files in a folder, merges them and removes duplicate rows. Explain each step.
Here's an error message from my program and the related code: [paste here]. Find the cause, suggest a patch and explain why it works.
Plan the migration of a small website from PHP to a static site framework: break the task into numbered steps, list the tools you'll need and the possible risks.

Tips for better results

  • In llama.cpp, turn on the built-in MTP layers with `--spec-type draft-mtp`. This can speed up text generation significantly.
  • Use `llama-server` with its built-in web interface at http://localhost:8080. The same server works as an OpenAI-compatible API for agent programs such as Pi, Hermes Agent or OpenClaw.
  • Give agents clear tasks with a goal, constraints and the output format you want. For JSON, it helps to include an example of the structure you're after.
  • If your graphics card is too small, offload expert layers to system RAM rather than dropping to a 2-bit file. Quality drops noticeably at IQ2.

If something goes wrong

The files need llama.cpp release b12174 or later. Older versions of llama.cpp, LM Studio or Ollama may not be able to load the architecture, so update first.

The model isn't in the official Ollama library. Load it straight from Hugging Face with `ollama run hf.co/bartowski/XingChen-AGI_Xing4.0-29B-A4B-GGUF:Q4_K_M`.

The model card doesn't specify a prompt format. If the answers look odd, check the chat template on the original page, XingChen-AGI/Xing4.0-29B-A4B.

The BF16 file is split into several parts and has to be downloaded as a complete folder.

The sources don't mention the license. Check it on the company's Hugging Face page before any commercial use.

A context window that's too large will overflow your VRAM, and the model will then run very slowly or not start at all. If that happens, reduce the context.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

  1. Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.