Monthly Outsourcing Costs of 500,000 Yen May Just Become Electricity Bills

In June, JetBrains released the open model “Mellum 2.1” for coding agents for free.

What’s noteworthy is not just the specifications. It includes a compact model with 25 million parameters that runs solely on a CPU. No GPU required. No cloud billing. An AI that writes code can operate on your personal computer.

What does this mean? The monthly payments of 300,000 to 500,000 yen that local small businesses pay to outsourced programmers could potentially be disrupted.

What Can Mellum 2.1 Do?

First, let’s clarify the facts.

Mellum 2.1 consists of two models:

• Mellum 2.1 12B MoE: A Mixture-of-Experts model with 12 billion parameters (operationally 2.5 billion). It has a context length of 131,072 tokens and has been trained through reinforcement learning (RL) in actual software environments.
• Mellum 2.1 25M: An ultra-compact model with 25 million parameters. It operates solely on a CPU and is specialized for code completion.

The performance of the 12B model is backed by benchmarks, scoring 51.6% on SWE-bench Verified and 82.0 on LiveCodeBench v6. These scores are comparable to models like Claude 3.5 Sonnet and GPT-4o. Moreover, it’s available with open weights under the Apache 2.0 license for free, allowing for commercial use.

The capabilities of the 12B model are clear: it autonomously explores codebases, edits files, and verifies its changes through tests. In other words, “Once instructed, it writes code on its own, tests it on its own, and fixes it on its own.” It can replace a significant portion of tasks that humans used to perform.

The 25M model has limited functionality, but its significance is different. It operates locally on a PC without the need for a GPU. There are no monthly fees or API costs. The barrier for small businesses to “give it a try” has vanished.

Breaking Down Outsourcing Costs

Now, let’s get to the main topic. When small businesses outsource programmers, how much are they actually paying?

The surface-level costs look like this:

However, the real costs are not just these. There are hidden costs.

• Communication Costs: Aligning specifications, checking progress, correcting misunderstandings. It’s common for in-house personnel to spend 5 to 10 hours a week on this, equating to 80,000 to 160,000 yen per month.
• Review and Acceptance Costs: Confirming the functionality of delivered code, reporting bugs, and requesting fixes. This can take 10 to 20 hours a month, costing 50,000 to 150,000 yen.
• Rework Costs: Redoing work due to misunderstandings of specifications. It’s said to occur in 30-40% of outsourced projects, with each instance costing tens of thousands of yen.
• Waiting Time Costs: Depending on the schedule of the outsourcing partner, it may take 2 to 4 weeks to start. During this time, business operations can come to a halt.

When these are summed up, it’s not uncommon for the apparent “monthly outsourcing cost of 400,000 yen” to actually exceed 600,000 to 800,000 yen.

Estimating the Costs of AI Coding

In contrast, what would be the cost of operating Mellum 2.1 in-house?

For the 25M model (CPU operation):

For the 12B model (GPU recommended):

In rough terms, the 25M model requires zero initial investment and nearly zero monthly costs. Even for the 12B model, it’s just a few tens of thousands of yen per month.

Where is the Break-Even Point?

Let’s do some simple calculations.

Assuming a small business with a monthly outsourcing cost of 400,000 yen (including real costs of 600,000 yen) operates the 12B model on a cloud GPU:

• AI Operating Cost: 50,000 yen per month (cloud GPU + in-house personnel time)
• Difference: 550,000 yen per month
• Annual Savings: 6.6 million yen

Even if AI can only replace 50% of outsourced tasks, it would still lead to an annual saving of 3.3 million yen.

Of course, AI won’t replace everything. Complex architecture design, business logic decisions, and security requirement considerations will remain human tasks for the foreseeable future. However, tasks like “adding standard screens,” “modifying existing code,” “generating test code,” and “identifying and fixing bugs” are already within the practical capabilities of AI.

The question is “how much can be replaced,” but what’s crucial is the fact that even a replacement rate of 20% can surpass the break-even point. With a real outsourcing cost of 600,000 yen and an AI operating cost of 50,000 yen, if AI replaces just 10% of outsourced tasks, it results in a monthly surplus of 10,000 yen. In other words, the costs have dropped to a level where “there’s no harm in trying”.

What Truly Changes is Not “Cost”

While cost reduction is an easy-to-understand topic, the structural change lies elsewhere.

The biggest change is “zero waiting time.”

When outsourcing, it takes a week for estimates, two weeks to start, and a month for delivery. That’s a total of two months. During that time, you can’t say, “I want to make a small change here.”

With AI, you can give instructions the moment you think of them. Code can be produced in 30 minutes. If it’s not right, you can issue correction instructions. Another 30 minutes. This speed of the cycle aligns with the decision-making speed of small businesses.

Large companies can afford to spend three months on requirement definitions. Small businesses cannot. “I need this feature by next week’s business meeting” or “I want to meet this month’s billing deadline.” Only an AI that operates locally can respond to this urgency.

Another point is the elimination of dependency.

The fear of accumulating code that “only that outsourced person understands” is something small business owners are likely familiar with. What if the outsourcing partner goes out of business? What if the person in charge leaves?

Code written by AI can be read by another AI. This structurally reduces handover costs. If you also have AI write code explanations, the risk of “this operation can’t run without this person” decreases.

So, What Should We Do?

You can start in three steps.

1. Install the 25M model today (Time required: 30 minutes)

Download it from JetBrains’ GitHub and run it on your personal PC. No GPU or cloud required. Check for yourself how effective code completion can be. The cost is zero.

2. Try doing one “small modification that was outsourced” with the 12B model

Run the 12B model on a cloud GPU (with services like RunPod or Vast costing just a few yen per hour) and throw in actual business tasks. Start with requests like, “Add a filter function to this screen” or “Change the format of this CSV output.”

3. Compare the costs with outsourcing and make a switch decision

Record the time and cost taken for each modification. Compare it with the estimates for outsourcing. Make decisions based on numbers, not gut feelings, but on experimental results.

It’s Not That Programmers Are Unnecessary. It’s That the Definition of a Programmer Changes.

Lastly, one more thing.

While the title mentions “the break-even point where programmers are unnecessary,” it’s more accurate to say that programmers won’t be unnecessary. What will become unnecessary is “the person who writes code by hand,” while there will be a need for “someone who can give correct instructions to AI.”

This is good news for small businesses. Hiring someone who has studied programming languages for five years is difficult. However, there might be someone in-house who “understands the business and can give precise instructions to AI.” It could be someone from sales administration or accounting.

As the cost of technology decreases, the value of business knowledge increases. This is the essence of structural change.

JetBrains’ Mellum 2.1 could serve as a trigger for this structural change. It’s free, runs on a CPU, and is available for commercial use. There are no excuses left.

First, I encourage you to download it today. In 30 minutes, the perspective on “that task you used to outsource” should change.