author: @kotauchisunsun
Release date: 2026/08/12
We have been operating a site called AI Coding.Info since July 2025.
This is a site that observes usage trends related to AI Coding Agents such as Claude Code, Codex CLI, Github Copilot, and Gemini from a fixed point from information in Github repositories. To determine the use of AI Coding Agent, we conduct daily surveys under the following conditions.
https://ai-coding.info/reports/articles/20260703
AI Coding Agent repository utilization rate was 13.0%, an increase of 0.9% from 12.1% last time.


AI Coding Agent usage rate on 2026/8/1
https://ai-coding.info/?date=2026-08-01#adoption-rate
AI Coding Agent usage rate on July 1, 2026
https://ai-coding.info/?date=2026-07-01#adoption-rate
Trends in AI Coding Agent usage rate from 2026/7/1 to 2026/8/1
https://ai-coding.info/?date=2026-04-01&since=2026-07-01&until=2026-08-01#share-trend
The share by product is as follows.
| Ranking | Product name | Share rate |
|---|---|---|
| 1st place | Codex CLI | 40.8% |
| 2nd place | Claude Code | 32.0% |
| 3rd place | Copilot Agent | 15.1% |
| 4th place | Gemini CLI(Antigravity) | 5.3% |
| 5th place | Cursor | 4.4% |
While the share of Codex CLI is increasing, Claude Code remains the same. Copilot Agent and Gemini CLI (Antigravity) are also showing a slight decline. Cursor is something I've been paying a little attention to. Cursor is acquired by SpaceX. There was news.
https://www.nikkei.com/article/DGXZQOGN16BC70W6A610C2000000/
Therefore, will there be a change in the share rate of this Cursor? I thought so, but last month it was 4.7% and this month it was 4.4%, so there isn't that much of a change. Looking at the number of repositories mentioned below, on July 1st, there were 85 repositories that adopted Cursor, and as of August 1st, the number remains unchanged at 85. Therefore, regarding this phenomenon, the population of repositories using AI Coding Agent has increased overall, but the number of Cursor usage has not increased. As a result, overall market share is declining. This has become a phenomenon. However, due to the characteristics of AI Coding.Info research, the number of repositories with Cursor-specific configuration files (.cursor) will not change. That being said, Cursor itself supports AGENTS.md. AI Coding.Info states that the number of repositories with AGENTS.md = the number of Codex CLI adoption, so although Cursor is used, it is possible that it is being counted as Codex CLI, and there is a possibility that the number of uses is increasing in an invisible part.

AI Coding Agent share rate on 8/1/2026
https://ai-coding.info/?date=2026-08-01&since=2026-07-01&until=2026-08-01#agent-share
AI Coding Agent share rate on 2026/7/1
https://ai-coding.info/?date=2026-07-01&since=2026-07-01&until=2026-08-01#agent-share
The programming language in which AI Coding Agent is used the most is "TypeScript," the second is "Python," the third is "Rust," the fourth is "Go," and the fifth is "C#." The adoption rate of AI Coding for TypeScript remains high, while the composition of Python'', Rust'', and Go'' as the second group, and C#'' as the third group has been a consistent trend in recent years.

AI Coding Agent ranking by programming language on 2026/8/1
https://ai-coding.info/?date=2026-08-01&since=2026-07-01&until=2026-08-01#language-agent-rank
AI Coding Agent ranking by programming language on July 1, 2026
https://ai-coding.info/?date=2026-07-01&since=2026-07-01&until=2026-08-01#language-agent-rank
The number of repositories was 1,794 as of 2026/07/01, but has increased to 1,940 as of 2026/08/01, and the number of repositories using AI Coding Agent has increased by 146.

Changes in the number of repositories using AI Coding Agent from 2026/7/1 to 2026/8/1
https://ai-coding.info/?date=2026-08-01&since=2026-07-01&until=2026-08-01#time-based-bar-chart
In June, the next generation of LLMs, Mythos and Fable 5, were released by Claude and shocked the industry with their performance. However, after that, China's Kimi company released an open weight model called Kimi-K3, which is almost Fable class. That became a hot topic. Even looking at the actual benchmarks, the numbers are close.

https://artificialanalysis.ai/#intelligence-category-tabs
When I thought that,
**Isn't local LLM also an option for AI Coding? **
I think you may think so. I investigated that area. The table below lists the major open weight LLM models from the graph above.
| Model Name | Company Name | Announcement Date | Number of Parameters | Number of Active Parameters | Context Length | Intelligence Index |
|---|---|---|---|---|---|---|
| Kimi K3(max) | Kimi(China) | 2026/07 | 2,800B | 104B | 1M | 60 |
| GLM-5.2(max) | Z AI(China) | 2026/06 | 756B | 40B | 1M | 53 |
| DeepSeek V4 Flash 0731 | DeepSeek(China) | 2026/07 | 284B | 13B | 1M | 52 |
| MiMo-V2.5-Pro | Xiaomi(China) | 2026/04 | 1,023B | 42B | 1M | 43 |
| Muse Glimmer (high) | Meta(USA) | 2026/08 | 30B | 256K | 35 | |
| Gemma 4 31B (Reasoning) | Google (USA) | 2026/04 | 30.7B | 256K | 30 |
However, do these actually work on your PC? I don't really understand that. Therefore, the determination method we considered was
The required VRAM memory is
2[GB] per parameter 1[B]
is. You can roughly estimate whether it will work based on the VRAM memory capacity of your PC and the number of parameters of the model you want to run. therefore,
**Mathematically, 5.6TB (5,600GB) of memory is required to run Kimi-K3. **
I will explain the reason for this. In the standard distributed LLM model, weights are expressed using decimal numbers with a precision of bf16 or fp16. These require 2 Bytes for each parameter. The notation you often see, such as 30[B], is the number of parameters, and B stands for billion and represents 10^9. Therefore, it can be seen that a model such as 30[B] has 30×10^9 weight data. And 1[GB]=1*10^9[Byte]. Thinking about it that way, we mentioned earlier that standard weights are stored in 2 Bytes, so it takes 2 Bytes per weight, which means 2 [GB] to store 1 [B] parameters in memory. This is the calculation. This is the meaning of "2[GB] per parameter 1[B]" mentioned earlier. However, this is just an approximation; this is the minimum requirement to load the weights into VRAM, and since memory may be used in addition to that, it is strictly advisable not to exceed it. This is the VRAM capacity.
This is where the concept of quantization comes into play. You may have seen Q4_0 or Q4_K_M. This is a technique that compresses the weight to its number of bits. Therefore, in the case of Q4_0, roughly speaking, the weight capacity is 4 bits (the 4 part of Q4_0). Therefore, in this case, the capacity is 0.5[GB] per 1[B]. A quick reference table of these looks like this:
| Quantization method | Required memory amount per 1[B] [GB] |
|---|---|
| bf16,fp16(standard) | 2.0 |
| Q8_0 | 1.0 |
| Q4_0 | 0.5 |
You may see a notation such as Q4_K_M, but roughly speaking, it is a model that increases accuracy compared to Q4_0, but uses slightly more memory capacity. It is good to be aware of this. There is another way to tell, simply look at the file size of the weight file (safetensor or gguf). If this exceeds the VRAM memory capacity, it will generally not work. I think you can think so.
From here, we have created a quick reference table of the amount of VRAM memory, quantization method, and number of parameters.
| VRAM memory capacity [GB] | Number of parameters (bf16,fp16)[B] | Number of parameters (Q8_0)[B] | Number of parameters (Q4_0)[B] |
|---|---|---|---|
| 8 | 4 | 8 | 16 |
| 16 | 8 | 16 | 32 |
| 24 | 12 | 24 | 48 |
| 32 | 16 | 32 | 64 |
| 64 | 32 | 64 | 128 |
| 128 | 64 | 128 | 256 |
| 256 | 128 | 256 | 512 |
| 512 | 256 | 512 | 1024 |
| 1024 | 512 | 1024 | 2048 |
| 2048 | 1024 | 2048 | 4096 |
Approximately how long can it be done? Considering that, if it is a model with 8GB of VRAM, it will be an RTX 5050, and the Amazon price is 55,000 yen. This may work if the model is about 8[B] quantized with Q8_0. That's the level.
When the VRAM increases to 16GB, it becomes a model around the RTX 5060 Ti, which costs about 108,000 yen. At this point, with Q4_0 quantization, a 30[B] class LLM will work or not. That's the level.
When the VRAM increases to 32GB, it becomes the RTX 5090 flagship model and costs 795,000 yen. When it comes to this, I guess it's at a level where you can't do it unless you have a lot of determination. I think so. This is the quantization of Q8_0, and whether the 30[B] class model works or not. It will be about the same level.
This area is the top line of consumer product level. Now, when it comes to the professional level, the RTX PRO 6000 Blackwell is equipped with 96GB of memory. **The price is 2.35 million yen. ** Here, even at the Q4_0 quantization level, only the 192[B] model works, so the flagship model does not work.
And since there was data for the GPU cluster to be installed on the server, I will post it for reference only. In the case of NVIDIA B300, the memory is 288GB and the price is 8.63 million yen. If it is one, DeepSeek V4 Flash 0731 with Q8_0 quantization may work. Q4_0 will work. If you have two (equivalent to 17 million yen), MiMo-V2.5-Pro with Q4_0 quantization may work.

https://www.nttpc.co.jp/cgi-bin/gpu/simulation/custom/index.cgi
Therefore, if you compare the amount of memory and the number of parameters, this is about it. Of course, there is more to debate than this, and whether or not this will be included in the memory. So, does it generate enough TOK/s to be used normally? There is another issue. This article talks about the very basics. LLM has architectures called Dense and MoE, and in MoE, only the active parameters are actually calculated, and depending on the execution method, there is a way to reduce the amount of physical memory by reading out the necessary Experts from storage, etc., instead of storing all Experts in memory all the time. However, there are some special aspects to the way the model is executed, and loading from storage to memory can become a bottleneck. There are some stories like this, but here we ignore such details and simply consider the capacity when all the weights of the model are stored in memory.
So, if you want to run the current Q4_0 or Q8_0 quantized flagship model, you'll need a machine that costs at least 10 million yen. That's the feel of it. On the other hand, it may work if you use special hardware to achieve even greater quantization. For example, there are people who are running 2-bit quantization and 3-bit quantization on the M4 Mac with 128GB memory (sold out) and DGX Spark (128GB memory).
https://zenn.dev/tkhr_sait/articles/20260508_try-local-deepseek-v4
https://dev.classmethod.jp/articles/dgx-spark-deepseek-v4-flash-0731-llama-cpp/
On the other hand, this is probably the limit for an individual. It's a skin feeling. Personally, I'm paying attention to 1-bit quantization. Famous models include Bonsai and technology such as BitNet, but the know-how for 1-bit quantization hasn't been made public, so I haven't tried it (it would probably take a huge amount of time and reduce inference accuracy).
So, personally, if a 1-bit quantized version of DeepSeek (approximately 35.5 GB) were released, I could see a world in which it could be run locally on a consumer-grade GPU, depending on some ingenuity, but as we currently don't have that, it's quite difficult. That's the honest truth.
Therefore,
**It is not realistic to run the flagship model with local LLM. **
That's my general impression. If you really want it to work, I think you need to do some testing.
This time, I focused my talk on local LLM. When Kimi-K3 came out, I was quite shocked, and the Fable class moved in the local LLM! It was quite impressive, but I can't even move it with the equipment I have. That was my honest impression. I posted an article about local LLM in the past, but it didn't work very well at that time, so I would like to dig a little deeper into it myself. I thought so.