The cost invariably goes down as production of any new technology ramps up though.

My heart bleeds for them.

It’s only a matter of time until somebody figures out how to mass produce a computing substrate that will make silicon look like vacuum tubes. We don’t need to discover any new physics here. Numerous substrates have been shown to outperform silicon by at least an order of magnitude in the lab. This is simply a matter of allocating resources in a sustained fashioned towards scaling these proofs of concept into mass production, something planned economies happen to excel at.

and cheap GPUs :)

The secret sauce here is how the model was trained. Typically, coding models are trained on static snapshots of code from GitHub and other public sources. They basically learn what good code looks like at a single point in time. IQuest did something totally different. They trained their model using entire commit history of repositories.

This approach added a temporal component to training, allowing the model to learn how code actually changes from one commit to the next. It saw how entire projects evolve over months and even years. It learned the patterns in how developers refactor and improve code, and the real world workflows of how software gets built. Instead of just learning what good code looks like, it learned how code evolves.

Coding is inherently an iterative process where you make an attempt at a solution, and then iterate on it. As you gain a deeper understanding of the problem, you end up building on top of existing patterns and evolving the codebase over time. IQuest model gets how that works because it was trained on that entire process.

Aww look at you still malding your color revolution failed.

The whole AI as a service business model is cooked now. My prediction is that even stuff like coding will soon work well enough with local models. There are going to be very few cases to justify paying subscription for AI services either for companies or individuals. And this stuff is moving so incredibly fast. For example https://dev.to/yakhilesh/china-just-released-the-first-coding-ai-of-2026-and-its-crushing-everything-we-know-3bbj

Gets called out on being a hypocrite, starts braying about tribalism. Peak liberal intellect in action here.

I love how libs throw around whataboutism as if it was anything other than exposing themselves as having a different set of standards for themselves and others.

To be fair, sales of all products have fallen in Europe as the result of European economies collapsing. And the specific reason for American products selling worse could simply be a result of American products are becoming more expensive in relative terms for the Europeans. with the moralizing being the justification rather than the core reason. Maybe if you want some real change you might want to figure out how to get out from under US occupation first. Don’t see Europeans rushing to dismantle all those American bases.

I see what you did there

What’s even funnier is that meta literally spent millions on each one of them.

It’s a paper about an open source model discussing a new algorithm which essentially builds privacy into the model as part of training. Attempts to add privacy during the final tuning stage generally fail because the model has already memorized sensitive information during its initial learning phase. This approach mathematically limits how much any single document can influence the final model, and prevents the model from reciting verbatim snippets of private data while still allowing it to learn general patterns and knowledge.

It’s really spurring Chinese companies to make LLMs that don’t need a lake of water to tell you how many r’s there are in strawberry. 🤣

I think slop should really be defined by the purpose of the art rather than the medium. Any piece of advertisement is inherently far more slop than a piece of genAI art somebody made because they just had an idea in their had they wanted to express.

would just be a dumb terminal that’s locked down

Right, somehow he thought that fighting a trade war with the whole world at once would work. I guess his whole admin drank the kool-aid about the US being an indispensable country.

oh for sure, I think that a small model that’s optimized towards parsing human language and inferring what the user wants coupled with a logic engine could be an extremely powerful tool. Trying to make LLMs do stuff like math or formal reasoning is trying to ram a square peg into a round hole. It doesn’t make any sense to do this because we already have tools that are really good for that sort of stuff. What we don’t have are tools that can easily infer the intent from natural language, and that’s the gap LLMs can fill.

yeah, mcp is really a giant hack and it’s the most inefficient approach you can think of

They’re absolutely not useless. The trick is to figure out how to use them effectively. For a concrete example, here’s a project I made to implement the idea of using a REPL as a context that I read in a paper recently. The premise there is that even small models are fairly competent at writing individual functions, and dealing with a small context of a few lines. So, instead of feeding large documents into these models which break them, you can instead provide them with an API to interrogate the document by writing code. And sure enough, the idea works. I managed to get qwen2.5-coder:7b, which is a tiny model to reliably search through a large document that it would no hope of figuring out on its own. Here’s what a run of it looks like:

npx tsx src/index.ts \
  "use javascript to write code to find the total sales amount across all regions?" \
  ./test-fixtures/scattered-data.txt \
  --verbose

  Configuration:
  Provider: ollama
  Model: qwen2.5-coder:7b
  Max turns: 10
  Timeout: 30000ms

[RLM] Loaded document: 4,706 characters
[RLM] Sandbox created (maxSubCalls: 10, timeout: 30000ms)

──────────────────────────────────────────────────
[Turn 1/10] Querying LLM...
[Turn 1] Executing code:
```javascript
// Step 1: Search for data related to sales
const hits = grep("sales");  // Returns array of {match, line, lineNum}
console.log(JSON.stringify(hits, null, 2));

// Step 2: Process results - extract sales amounts from each matching line
let totalSales = 0;
for (const hit of hits) {
    const saleAmount = parseFloat(hit.line.match(/\d+(\.\d{1,2})?/)[0]);
    if (!isNaN(saleAmount)) {
        totalSales += saleAmount;
    }
}

// Step 3: Store the result in memory
memory.push({ key: "total_sales", value: totalSales });

// Final output
console.log("Total sales across all regions:", totalSales);
```
[Turn 1] Console output:
  [
  ...
  {
    "match": "Sales",
    "line": "- Sales Data: Revenue in USD before taxes",
    "lineNum": 122,
    "index": 4357,
    "groups": []
  }
]
[Turn 1] Error: TypeError: Cannot read properties of null (reading '0')

──────────────────────────────────────────────────
[Turn 2/10] Querying LLM...
[Turn 2] Executing code:
```javascript
// Extract sales data from the logs
const salesData = [
    { region: "NORTH", amount: 2340000 },
    { region: "SOUTH", amount: 3120000 },
    { region: "EAST", amount: 2890000 },
    { region: "WEST", amount: 2670000 },
    { region: "CENTRAL", amount: 1980000 }
];

// Calculate total sales
const totalSales = salesData.reduce((acc, curr) => acc + curr.amount, 0);

// Output the total sales
console.log("Total Sales:", totalSales);
```
[Turn 2] Console output:
  Total Sales: 13000000

──────────────────────────────────────────────────
[Turn 3/10] Querying LLM...
[Turn 3] Executing code:
```javascript
// Output the total sales
console.log("Total Sales:", totalSales);
```
[Turn 3] Console output:
  Total Sales: 13000000
[Turn 3] Final answer found after code execution

[RLM] Sandbox disposed
The total sales are 13000000.

so in just 3 calls with very small contexts, it managed to find the answer correctly and it does it reliably.

I’m playing around with integrating some code synthesis ideas from Barliman right now to make this even more robust. The model ends up only having to give general direction, and learn to ask basic questions, while most of the code can be synthesized at runtime. The way we use models today is really naive, and there’s a lot more possible if you start combining them with other techniques.