<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: albe_sf</title>
    <description>The latest articles on DEV Community by albe_sf (@albertomontagnese).</description>
    <link>https://dev.to/albertomontagnese</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3928059%2F8788e7f6-c941-4959-b1cf-18686efc9034.jpg</url>
      <title>DEV Community: albe_sf</title>
      <link>https://dev.to/albertomontagnese</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/albertomontagnese"/>
    <language>en</language>
    <item>
      <title>Google's Gemini 4 Argon release is a bet on agentic security</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Wed, 14 Oct 2026 15:03:40 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/googles-gemini-4-argon-release-is-a-bet-on-agentic-security-1f8m</link>
      <guid>https://dev.to/albertomontagnese/googles-gemini-4-argon-release-is-a-bet-on-agentic-security-1f8m</guid>
      <description>&lt;p&gt;Google has made its latest frontier model, Gemini 4 Argon, available to developers. This isn't just another incremental update; it's a specialized tool designed for complex, long-horizon tasks in cybersecurity, software engineering, and enterprise knowledge work. The release indicates a clear strategic direction: the future of applied AI isn't just conversational chat, but autonomous agents integrated directly into critical infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  what is gemini 4 argon?
&lt;/h2&gt;

&lt;p&gt;Gemini 4 Argon is positioned as a frontier model for high-complexity workflows. Initial access appears to be rolling out in phases, with early availability for vetted cybersecurity defenders, followed by a broader release to developers through the Gemini API's paid tier. This controlled rollout underscores its focus on sensitive, high-stakes domains.&lt;/p&gt;

&lt;p&gt;The model is built to handle tasks that require deep reasoning and precision, such as code migrations and vulnerability analysis. This specialization moves beyond the capabilities of general-purpose models, targeting the specific needs of security operations centers (SOCs) and software engineering teams who deal with constant threats and complex codebases.&lt;/p&gt;

&lt;h2&gt;
  
  
  more than a model: an autonomous platform
&lt;/h2&gt;

&lt;p&gt;The release of Argon is best understood as a component within a larger strategy for AI-driven security. Google is assembling an always-on, autonomous security platform, and this model provides the reasoning engine. It plugs into a broader ecosystem that includes the Security AI Workbench and Chronicle Security Operations, which aim to help defenders manage threat overload with AI-powered analysis.&lt;/p&gt;

&lt;p&gt;This is a direct response to an industry-wide problem: as AI is used to discover new vulnerabilities, human analysts cannot keep pace. The only viable defense is to deploy AI agents that can operate at machine speed. Google's existing triage and investigation agent, powered by Gemini, has already demonstrated this by reducing alert analysis time from 30 minutes to about one minute. Argon represents the next step in this evolution, enabling more complex and autonomous defensive actions.&lt;/p&gt;

&lt;h2&gt;
  
  
  putting agentic security to work
&lt;/h2&gt;

&lt;p&gt;For builders, the most immediate application is in automated code remediation. An AI agent called CodeMender, which uses Gemini models, is designed to automatically find and fix critical code vulnerabilities. This shifts security from a reactive, manual process to a proactive, automated one.&lt;/p&gt;

&lt;p&gt;You can imagine configuring such an agent to continuously monitor a repository, identify potential vulnerabilities, and propose patches. The workflow would be defined declaratively, with the model handling the complex reasoning required to understand the code and generate a secure fix.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="c1"&gt;# hypothetical config for a CodeMender-style agent&lt;/span&gt;

&lt;span class="na"&gt;version&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="m"&gt;1.0&lt;/span&gt;

&lt;span class="na"&gt;agent&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;repo-security-agent-prod&lt;/span&gt;
  &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;gemini-4-argon&lt;/span&gt;
  &lt;span class="na"&gt;mode&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;continuous_monitoring&lt;/span&gt;

&lt;span class="na"&gt;triggers&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;on_commit&lt;/span&gt;
    &lt;span class="na"&gt;branch&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;main&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;on_dependency_update&lt;/span&gt;
    &lt;span class="na"&gt;package_manager&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;npm&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;scheduled&lt;/span&gt;
    &lt;span class="na"&gt;cron&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;'&lt;/span&gt;&lt;span class="s"&gt;0&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;2&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;*&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;*&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;*'&lt;/span&gt; &lt;span class="c1"&gt;# daily at 2am UTC&lt;/span&gt;

&lt;span class="na"&gt;capabilities&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;static_analysis&lt;/span&gt;
    &lt;span class="na"&gt;rulesets&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;owasp-top-10"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;common-misconfigurations"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;dependency_graph_vuln_scan&lt;/span&gt;
    &lt;span class="na"&gt;severity_threshold&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;high&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;automated_patch_generation&lt;/span&gt;

&lt;span class="na"&gt;actions&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;on_vulnerability_found&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
      &lt;span class="na"&gt;if&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;severity &amp;gt;= high&lt;/span&gt;
      &lt;span class="na"&gt;then&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; 
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;create_issue&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;generate_patch&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="na"&gt;assign_review&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;@security-team"&lt;/span&gt;&lt;span class="pi"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;@lead-dev"&lt;/span&gt;&lt;span class="pi"&gt;]&lt;/span&gt;
      &lt;span class="na"&gt;else&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
        &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;log_to_dashboard&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This configuration delegates the entire scan-and-remediate loop to an autonomous system. The value is not just in the model's ability to reason about code, but in its integration into a persistent, agentic workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  the so-what for builders
&lt;/h2&gt;

&lt;p&gt;Gemini 4 Argon is a signal that the AI tooling landscape is maturing. We are moving past the novelty of general-purpose models and into an era of specialized agents that perform critical business functions. For engineers, this means the focus will shift from prompt engineering for chat interfaces to designing, configuring, and orchestrating autonomous systems.&lt;/p&gt;

&lt;p&gt;The core challenge is no longer just getting a model to produce a correct answer. It is about reliably integrating that model's reasoning capabilities into production workflows that can run safely and continuously without direct human supervision. That's a fundamentally different and more interesting engineering problem.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://blog.google/" rel="noopener noreferrer"&gt;https://blog.google/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>devtools</category>
      <category>news</category>
    </item>
    <item>
      <title>Anthropic's New Dynamic Workflows Let Agents Write and Run Their Own Programs</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Mon, 12 Oct 2026 15:04:57 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/anthropics-new-dynamic-workflows-let-agents-write-and-run-their-own-programs-6ig</link>
      <guid>https://dev.to/albertomontagnese/anthropics-new-dynamic-workflows-let-agents-write-and-run-their-own-programs-6ig</guid>
      <description>&lt;p&gt;Anthropic just enabled dynamic workflows for its Claude Managed Agents, a move that pushes agentic systems beyond simple tool-use into autonomous, multi-step execution. An agent can now write and run its own programs in the background to orchestrate up to a thousand sub-agents for complex tasks.&lt;/p&gt;

&lt;p&gt;This isn't just another API feature; it's a shift in how we can architect and deploy systems that handle work at scale, like processing hundreds of documents or auditing large codebases.&lt;/p&gt;

&lt;h2&gt;
  
  
  what just shipped
&lt;/h2&gt;

&lt;p&gt;On October 9, in its platform release notes, Anthropic detailed the new beta feature. Instead of a developer defining a rigid chain of tasks, a managed agent can now dynamically write a workflow—a program that runs other agents in phases and combines their results. This entire workflow then executes on Anthropic's servers as a background run, allowing the primary user-facing session to continue without being blocked.&lt;/p&gt;

&lt;p&gt;The scale is significant. A single workflow run can orchestrate up to 1,000 agents over its lifetime, with as many as 64 agents working concurrently. In an internal test, Anthropic reported that a single agent found between 14 and 27 of 70 bugs planted in a large codebase, whereas a dynamic workflow consistently found 66.&lt;/p&gt;

&lt;h2&gt;
  
  
  why this is a step-change for builders
&lt;/h2&gt;

&lt;p&gt;This model moves past simple delegation. The key distinction is that the lead agent writes code to orchestrate the other agents, passing context and results between them without its own direct involvement in every step. The orchestration logic itself is a program, not just another model turn.&lt;/p&gt;

&lt;p&gt;More importantly, the agent decides for itself when to initiate a run based on the user's request and its system prompt. This autonomy is a fundamental change. Your prompt is no longer just a request for an answer; it's a potential trigger for a complex, multi-agent process that runs independently in the cloud.&lt;/p&gt;

&lt;p&gt;For anyone building production agents, this pattern solves the problem of long-running, complex tasks that would otherwise time out or require a complex state-management system on the client side.&lt;/p&gt;

&lt;h2&gt;
  
  
  how to use it (and the gotchas)
&lt;/h2&gt;

&lt;p&gt;The feature is in beta and must be explicitly enabled. It's accessible via the Claude Developer Platform by using a specific beta header (&lt;code&gt;managed-agents-2026-04-01&lt;/code&gt;). To configure it, you enable workflows within your agent's &lt;code&gt;multiagent&lt;/code&gt; settings.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"multiagent"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"multiagent_20261001"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"workflows"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
      &lt;/span&gt;&lt;span class="nl"&gt;"type"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"enabled"&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Once enabled, you guide the agent on when to use workflows via its system prompt. You can then monitor the progress through &lt;code&gt;workflow_run&lt;/code&gt; events in your session's event stream.&lt;/p&gt;

&lt;p&gt;The primary gotcha is cost and control. While there's no fee for the workflow run itself, you are billed for the tokens used by every agent in the run, plus a session runtime fee. Since the agent decides when to start a run, setting a budget is the main brake on a process that could otherwise consume significant resources.&lt;/p&gt;

&lt;h2&gt;
  
  
  the takeaway
&lt;/h2&gt;

&lt;p&gt;Anthropic's dynamic workflows are a strong signal of where the industry is heading. We are moving from single-shot, human-in-the-loop tools toward persistent, autonomous agents that can manage and execute complex, long-running jobs.&lt;/p&gt;

&lt;p&gt;For developers, this means thinking less about managing individual API calls and more about designing systems of agents and the guardrails they operate within. It's a more powerful but also more abstract way of building, and it's here now.&lt;/p&gt;

&lt;h2&gt;
  
  
  sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.anthropic.com/" rel="noopener noreferrer"&gt;Anthropic Platform Release Notes (as reported by multiple outlets)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>claude</category>
      <category>agents</category>
    </item>
    <item>
      <title>Mistral's 'Le Chonk' is a Trillion-Parameter Bet on Open Weights</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Fri, 09 Oct 2026 15:05:49 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/mistrals-le-chonk-is-a-trillion-parameter-bet-on-open-weights-458g</link>
      <guid>https://dev.to/albertomontagnese/mistrals-le-chonk-is-a-trillion-parameter-bet-on-open-weights-458g</guid>
      <description>&lt;p&gt;Mistral just pushed its new flagship model, Mistral Large 4, into public preview. This is a trillion-parameter, multimodal mixture-of-experts system positioned for complex work like cybersecurity and agentic reasoning. The key takeaway isn't just the scale, but Mistral's commitment to release the model weights by the end of the month, continuing their push for open, self-hostable foundation models.&lt;/p&gt;

&lt;h2&gt;
  
  
  what it is
&lt;/h2&gt;

&lt;p&gt;Mistral Large 4, or ML4, is a massive model with a playful nickname: 'le Chonk'. It's a mixture-of-experts (MoE) architecture with a reported one trillion parameters, of which around 49 to 52 billion are active for any given token. This MoE design allows for a very large model capacity while managing inference costs. The model is natively multimodal, built to process both text and images.&lt;/p&gt;

&lt;p&gt;Mistral is explicit about the model's target workloads: cybersecurity, finance, and agentic AI. They claim it ranks among the best open-weight models, designed to compete with top-tier systems from US and Chinese labs. The training was done from scratch on 3,800 NVIDIA GPUs in Mistral's own European data centers, a detail they highlight as part of a strategy for 'AI sovereignty'.&lt;/p&gt;

&lt;h2&gt;
  
  
  why it matters for builders
&lt;/h2&gt;

&lt;p&gt;The most significant part of this release is the pending open-weight drop. While the preview API is available now through Mistral Studio, the company stated the weights will be released by the end of October 2026. This opens the door for self-hosting, fine-tuning, and deep auditing that closed models don't allow.&lt;/p&gt;

&lt;p&gt;For teams working in sensitive domains like security, this is critical. Running a model on your own infrastructure means your data and intellectual property remain under your control. Mistral emphasizes this, noting that ML4 gives organizations the autonomy to run advanced security work under their own policies without provider-level refusals blocking legitimate research.&lt;/p&gt;

&lt;p&gt;The focus on agentic capabilities is also notable. The announcement materials suggest the model is built for tool use and complex, multi-step tasks, which is where many production systems are heading.&lt;/p&gt;

&lt;h2&gt;
  
  
  how to use it (and the gotchas)
&lt;/h2&gt;

&lt;p&gt;You can access the model today via the preview API on Mistral Studio. This is the best way to evaluate its capabilities on your specific workloads before committing to a self-hosted deployment. Mistral has not yet published pricing for the preview API.&lt;/p&gt;

&lt;p&gt;Here's a conceptual snippet for what an API call might look like, based on typical patterns:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;mistralai.client&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;MistralClient&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;mistralai.models.chat_completion&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;ChatMessage&lt;/span&gt;

&lt;span class="n"&gt;api_key&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;os&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;environ&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;MISTRAL_API_KEY&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;mistral-large-4-preview&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="n"&gt;client&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;MistralClient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;api_key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;api_key&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# Example for a simple text-based query
&lt;/span&gt;&lt;span class="n"&gt;chat_response&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;chat&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="nc"&gt;ChatMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
            &lt;span class="n"&gt;role&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Audit this smart contract for potential reentrancy vulnerabilities.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
        &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;chat_response&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;choices&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The primary gotcha is that this is a preview. Mistral has stated that the reinforcement learning process is still ongoing, and they expect performance to improve before the final release. The second consideration is the hardware requirement for self-hosting. A trillion-parameter model is not trivial to run. While the MoE architecture makes inference more efficient than a dense model of the same size, the memory footprint to simply load the weights will be substantial.&lt;/p&gt;

&lt;h2&gt;
  
  
  the takeaway
&lt;/h2&gt;

&lt;p&gt;Mistral Large 4 is another major entry in the open-weight arena. It puts a frontier-scale model within reach of any team willing to manage the infrastructure. For builders focused on security, data privacy, or building complex agents, the upcoming weights release is the event to watch. This is less about a single new API endpoint and more about the increasing viability of a powerful, sovereign AI stack.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://mistral.ai/" rel="noopener noreferrer"&gt;Introducing Mistral Large 4&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://mistral.ai/" rel="noopener noreferrer"&gt;Mistral's New 'Le Chonk' AI Model Is Big, Open and Built for Agents - CNET&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://mistral.ai/" rel="noopener noreferrer"&gt;Mistral Large 4 (Le Chonk): A Review of Europe's Trillion-Parameter Model and Its Open-Weight Promise&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>opensource</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>EmbeddingGemma 2: A Practical Multimodal Embedder for On-Device AI</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Wed, 07 Oct 2026 15:03:32 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/embeddinggemma-2-a-practical-multimodal-embedder-for-on-device-ai-5b7j</link>
      <guid>https://dev.to/albertomontagnese/embeddinggemma-2-a-practical-multimodal-embedder-for-on-device-ai-5b7j</guid>
      <description>&lt;p&gt;Google DeepMind just released EmbeddingGemma 2, a 740-million-parameter open model that maps five different modalities into a single, shared vector space. [2] For engineers building on-device search or retrieval-augmented generation systems, this is a significant release. It provides a lightweight, modular architecture for multimodal embeddings without requiring cloud-scale infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  a unified vector space for everything
&lt;/h2&gt;

&lt;p&gt;EmbeddingGemma 2 is an open model released under an Apache 2.0 license that projects text, code, images, video, and audio into a shared 768-dimensional embedding space. [2, 4] This unification is the core value proposition. You can now perform cross-modal retrieval, like searching a video library with a text query or finding a code snippet using an audio memo, within a single coherent system. [2]&lt;/p&gt;

&lt;p&gt;The model is built on the Gemma 4 architecture and, at 740M parameters, is explicitly designed to run on consumer hardware. [2] This isn't a massive, multi-billion parameter model that only lives in a datacenter. The goal here is enabling privacy-first, on-device applications where user data never leaves the machine. [5]&lt;/p&gt;

&lt;h2&gt;
  
  
  modular encoders are the main story
&lt;/h2&gt;

&lt;p&gt;The most important design choice for builders is the model's modularity. The 740M parameters are not a single monolithic block. Instead, the model combines several independent encoders: a 270-million-parameter text model, a 170M-parameter vision encoder, and a 300M-parameter audio encoder. [2]&lt;/p&gt;

&lt;p&gt;Because these encoders are independent, you can selectively load only the components required for your application from the same checkpoint. [2] If your app only needs to search text and code, you load the 270M text model. If you're building a tool to organize photos, you load the 440M text and vision configuration. This allows you to manage the memory footprint precisely. On a Pixel 11 Pro, the text-only version uses about 191MB of active memory, while the full multimodal setup requires about 567MB. [5]&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="c1"&gt;# Conceptual example of selectively loading encoders
&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;EmbeddingGemma&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;__init__&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;checkpoint_path&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;checkpoint&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;load_checkpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;checkpoint_path&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;text_encoder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;None&lt;/span&gt;
        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;vision_encoder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;None&lt;/span&gt;
        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;audio_encoder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="bp"&gt;None&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;load_text_and_code&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="c1"&gt;# Load 270M text model from the main checkpoint
&lt;/span&gt;        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;text_encoder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;init_text_from_checkpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;checkpoint&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;load_vision&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="c1"&gt;# Add 170M vision encoder
&lt;/span&gt;        &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;vision_encoder&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;init_vision_from_checkpoint&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;checkpoint&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;embed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;modality&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;modality&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;text_encoder&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;text_encoder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="n"&gt;modality&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;image&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt; &lt;span class="ow"&gt;and&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;vision_encoder&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;vision_encoder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;process&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
            &lt;span class="k"&gt;raise&lt;/span&gt; &lt;span class="nc"&gt;ValueError&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Modality &lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;modality&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt; not loaded or supported.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# Usage:
# For a text-only RAG pipeline on a low-memory device
&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;EmbeddingGemma&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;path/to/embeddinggemma-2-740m&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;load_text_and_code&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;text_embedding&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;embed&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;def fibonacci(n): ...&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;modality&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This modular approach makes the model far more practical for real-world deployment on constrained devices.&lt;/p&gt;

&lt;h2&gt;
  
  
  performance and practical tradeoffs
&lt;/h2&gt;

&lt;p&gt;Smaller models often mean performance compromises, but EmbeddingGemma 2 holds its own. It reportedly improves on its predecessor's code retrieval performance by a significant margin, jumping 9.92 points on the MTEB Code benchmark. [2]&lt;/p&gt;

&lt;p&gt;To further manage resources, the model supports Matryoshka Representation Learning (MRL). This technique allows you to truncate the 768-dimension vectors down to 512, 256, or even 128 dimensions to reduce storage and compute requirements. [4] This is a direct trade-off. For text-only workloads, truncating to 256 dimensions results in a minimal performance dip on multilingual benchmarks. [4] However, for image tasks, dropping to 128 dimensions causes a more noticeable degradation, so the team recommends 128d primarily for text-only use cases. [4]&lt;/p&gt;

&lt;h2&gt;
  
  
  the takeaway for builders
&lt;/h2&gt;

&lt;p&gt;EmbeddingGemma 2 makes multimodal, on-device AI more accessible. The combination of a unified embedding space, a modular design, and techniques like MRL provides the flexibility needed to ship sophisticated search and RAG features on hardware people already own. It's an open, practical tool for building applications that are both capable and private.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.unite.ai/deepmind-debuts-embeddinggemma-2-mapping-five-modalities-into-one-space/" rel="noopener noreferrer"&gt;Google DeepMind Debuts EmbeddingGemma 2, Mapping Five Modalities Into One Space (Unite.AI)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.marktechpost.com/2026/10/06/google-deepmind-releases-embeddinggemma-2-a-740m-open-multimodal-embedding-model-built-on-gemma-4/" rel="noopener noreferrer"&gt;Google DeepMind Releases EmbeddingGemma 2, a 740M Open Multimodal Embedding Model Built on Gemma 4 (MarkTechPost)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>opensource</category>
      <category>devtools</category>
    </item>
    <item>
      <title>Omnigent is a Meta-Harness For Your AI Agents</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Mon, 05 Oct 2026 15:03:49 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/omnigent-is-a-meta-harness-for-your-ai-agents-coa</link>
      <guid>https://dev.to/albertomontagnese/omnigent-is-a-meta-harness-for-your-ai-agents-coa</guid>
      <description>&lt;p&gt;A new open-source agent framework, Omnigent, just launched. It's a meta-harness designed to give you a common orchestration layer over the diverse and growing landscape of coding agents, letting you swap or combine them without rewriting core logic.&lt;/p&gt;

&lt;p&gt;This approach abstracts the harness, so you can focus on the task rather than the specific agent implementation. It's a control plane for agents, and it points to a future where we build with a portfolio of specialized AI systems instead of a single, monolithic one.&lt;/p&gt;

&lt;h2&gt;
  
  
  what is a meta-harness
&lt;/h2&gt;

&lt;p&gt;Omnigent isn't another agent; it's a framework for managing other agents. The core idea is to provide a single interface for interacting with models and agents from different providers, including Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, and custom agents you define yourself.&lt;/p&gt;

&lt;p&gt;This lets you treat different agent backends as interchangeable components. The framework handles the session management, ensuring that messages, terminals, and files stay in sync whether you're interacting from a terminal, a browser, or the native desktop app. Sessions follow you across devices, allowing you to start a task on one machine and continue it on another.&lt;/p&gt;

&lt;h2&gt;
  
  
  why this matters for builders
&lt;/h2&gt;

&lt;p&gt;The immediate, practical benefit is avoiding vendor lock-in. If a better or more cost-effective agent becomes available, you can swap it in without a significant rewrite. But the more interesting implications are in multi-agent workflows.&lt;/p&gt;

&lt;p&gt;Omnigent is designed to supervise multiple, heterogeneous agents within the same session. You can, for example, assign a coding task to one agent and then have a different agent, known for its review capabilities, inspect the output. This allows you to build more robust systems by composing agents with different strengths, much like you'd build a human team.&lt;/p&gt;

&lt;p&gt;Furthermore, the framework provides a centralized point for governance and safety. You can create policies to enforce spend caps, require human approval for risky actions, or limit the tools an agent can access. These policies can be applied globally to the server, to a specific agent, or even to a single chat session.&lt;/p&gt;

&lt;h2&gt;
  
  
  how it works
&lt;/h2&gt;

&lt;p&gt;Getting started involves a single installation command which bundles the framework and its dependencies.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# One command installs Omnigent and its dependencies&lt;/span&gt;
pip &lt;span class="nb"&gt;install &lt;/span&gt;omnigent
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Beyond local execution, a key feature is the ability to run agents in cloud sandboxes. The system supports a range of disposable environments, including Modal, Daytona, Kubernetes, and others. This means you can run agentic sessions without tying up your local machine, with the server provisioning sandboxes as needed. This is critical for long-running tasks and for maintaining a clean, secure execution environment for agent actions.&lt;/p&gt;

&lt;p&gt;Custom agents can be defined in YAML, allowing you to integrate your own specialized tools and models into the orchestration layer alongside the pre-integrated commercial agents.&lt;/p&gt;

&lt;h2&gt;
  
  
  the takeaway
&lt;/h2&gt;

&lt;p&gt;The proliferation of AI agents creates a new problem: managing them. A meta-harness like Omnigent suggests a solution based on abstraction and orchestration. Instead of committing to a single agent architecture, you can use a supervisory layer to mix, match, and govern them.&lt;/p&gt;

&lt;p&gt;For builders, this is a step towards more resilient and powerful AI systems. It allows you to leverage the best agent for each part of a complex task and enforce consistent rules across all of them. It's a toolkit for moving from single-agent applications to true multi-agent systems.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://omnigent.ai" rel="noopener noreferrer"&gt;omnigent.ai&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>opensource</category>
      <category>devtools</category>
    </item>
    <item>
      <title>The Assistants API is Gone. Here's How to Build Agents Now.</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Fri, 02 Oct 2026 15:04:00 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/the-assistants-api-is-gone-heres-how-to-build-agents-now-3428</link>
      <guid>https://dev.to/albertomontagnese/the-assistants-api-is-gone-heres-how-to-build-agents-now-3428</guid>
      <description>&lt;p&gt;The OpenAI Assistants API was officially shut down on August 26, 2026. This deprecation forces a fundamental shift in how we build stateful agents, moving from a managed, persistent-thread model to a more direct, stateless approach with the new Responses and Conversations APIs. This change simplifies some parts of the stack but places the responsibility for state management squarely back on you, the developer.&lt;/p&gt;

&lt;h2&gt;
  
  
  what changed: from assistants to responses
&lt;/h2&gt;

&lt;p&gt;The original Assistants API was an attempt to abstract away the complexity of building conversational AI. It provided a stateful environment with persistent "threads," allowing developers to build agents that could maintain context over long interactions without managing the conversation history themselves. It also bundled powerful tools like Code Interpreter and a retrieval system.&lt;/p&gt;

&lt;p&gt;However, this abstraction came with trade-offs. The API could feel clunky, and its stateful nature led to unpredictable costs, as the entire conversation thread might be re-processed on every turn. Performance was also a concern, as developers had to poll for updates rather than using a real-time stream.&lt;/p&gt;

&lt;p&gt;The new model, centered on the Responses API, is a return to a more primitive, stateless paradigm. The core idea is a direct request/response flow. Persistent threads are replaced by &lt;code&gt;Conversation&lt;/code&gt; objects, which you must create and manage. The responsibility for maintaining context between turns now falls to your application code. This is a significant architectural change, but one that offers more control, better performance, and more predictable costs.&lt;/p&gt;

&lt;h2&gt;
  
  
  the new core of RAG: file_search
&lt;/h2&gt;

&lt;p&gt;For developers building Retrieval-Augmented Generation (RAG) systems, the most important change is the introduction of the &lt;code&gt;file_search&lt;/code&gt; tool within the Responses API. This is the successor to the old &lt;code&gt;Retrieval&lt;/code&gt; tool and is now the standard way to have models access knowledge from your private documents.&lt;/p&gt;

&lt;p&gt;The workflow is straightforward: you create a &lt;code&gt;vector_store&lt;/code&gt;, upload your files to it, and OpenAI's backend handles the entire pipeline of chunking, embedding, and indexing. You no longer have to build and manage your own embedding and retrieval logic.&lt;/p&gt;

&lt;p&gt;When you make a call to the Responses API, you can make the &lt;code&gt;file_search&lt;/code&gt; tool available. The model then intelligently decides when to use it based on the user's query. It performs a semantic search against your vector store, retrieves the most relevant passages, and incorporates them into its response, complete with citations.&lt;/p&gt;

&lt;p&gt;Here is a conceptual look at what an API call might look like in Python, enabling the tool for a specific vector store:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;openai&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;OpenAI&lt;/span&gt;
&lt;span class="n"&gt;client&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;OpenAI&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;

&lt;span class="c1"&gt;# Assuming a vector_store_id has been created and files uploaded
&lt;/span&gt;&lt;span class="n"&gt;vector_store_id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;vs_123abc&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="c1"&gt;# Create a conversation and add a user message
&lt;/span&gt;&lt;span class="n"&gt;conversation&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;conversations&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;conversations&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;conversation_id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;conversation&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;role&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;What were the key findings in the Q3 financial report?&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# Create a response, enabling the file_search tool
&lt;/span&gt;&lt;span class="n"&gt;response&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;responses&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;gpt-6.1-sol&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;conversation_id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;conversation&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;tools&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[{&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;file_search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;file_search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;vector_store_ids&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;vector_store_id&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# The response will contain the model's answer,
# potentially using information retrieved from the file search.
&lt;/span&gt;&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;output&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  what you gain and what you lose
&lt;/h2&gt;

&lt;p&gt;The primary gain from this migration is control. The move to a stateless API gives you direct authority over conversation history and state management. This means more predictable performance and costs, as you are no longer subject to the black box of the old persistent-thread system. The Responses API also consolidates complex workflows into a single API call, simplifying the overall interaction model.&lt;/p&gt;

&lt;p&gt;The most significant loss is convenience. The hand-holding of the managed, infinite-context thread is gone. If your application was architected around the assumption that OpenAI would manage the state, you now have a non-trivial migration project ahead of you. OpenAI does not provide an automatic tool for migrating old Threads to new Conversations.&lt;/p&gt;

&lt;p&gt;There is also a key technical trade-off with the managed &lt;code&gt;file_search&lt;/code&gt; tool. While it removes the burden of building a RAG pipeline, it also takes away your control over the chunking strategy. For highly structured or complex documents, the automated chunking might not be optimal, which can impact the quality of retrieval. This is a critical limitation to be aware of when deciding whether to use the built-in tool or roll your own retrieval system.&lt;/p&gt;

&lt;h3&gt;
  
  
  the final word
&lt;/h3&gt;

&lt;p&gt;This shift marks a maturation of the AI developer stack. The initial, heavily-abstracted Assistants API has been replaced by more powerful and primitive building blocks. It’s a move away from providing a magic box and toward giving engineers direct access to the core components of RAG and agentic systems. For builders, this means more responsibility, but also more power. The era of the fully managed agent is over; the era of building your own is here.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://platform.openai.com/docs/assistants/migration" rel="noopener noreferrer"&gt;Assistants migration guide | OpenAI API&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://platform.openai.com/docs/guides/tools-file-search" rel="noopener noreferrer"&gt;File search | OpenAI API&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>machinelearning</category>
      <category>python</category>
    </item>
    <item>
      <title>Anthropic's Sonnet 5.5 release is about cost-per-task, not peak performance</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Wed, 30 Sep 2026 15:04:14 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/anthropics-sonnet-55-release-is-about-cost-per-task-not-peak-performance-27i6</link>
      <guid>https://dev.to/albertomontagnese/anthropics-sonnet-55-release-is-about-cost-per-task-not-peak-performance-27i6</guid>
      <description>&lt;p&gt;Anthropic released Claude Sonnet 5.5 this week, and the main takeaway isn't a new state-of-the-art benchmark. The real story is the focus on cost-per-task for the bulk of everyday engineering work. This isn't a model for moonshots; it's a workhorse for bug fixes, documentation, and routine code generation, where speed and efficiency matter more than cutting-edge reasoning.&lt;/p&gt;

&lt;h2&gt;
  
  
  what changed
&lt;/h2&gt;

&lt;p&gt;Sonnet 5.5 is the second model in Anthropic's 5.5 family, positioned as a faster, more economical alternative to the top-tier Claude Opus 5.5. Where Opus is designed for complex tasks requiring careful judgment, Sonnet is aimed at well-defined, everyday work.&lt;/p&gt;

&lt;p&gt;The key improvements over its predecessor, Sonnet 5, are in efficiency. Sonnet 5.5 generates output over 30% faster. While the per-token pricing remains the same, Anthropic claims it costs up to 30% less for most tasks because it requires fewer tokens to complete the same work.&lt;/p&gt;

&lt;p&gt;The performance jump on agentic coding is significant. On the Terminal-Bench 4.0 evaluation, Sonnet 5.5 scored 70.6%, a massive leap from Sonnet 5's 10.3%. This suggests it's far more capable for tasks that require tool use and autonomous operation within a terminal environment.&lt;/p&gt;

&lt;h2&gt;
  
  
  why it matters for builders
&lt;/h2&gt;

&lt;p&gt;The most expensive model is rarely the right tool for every job. The release of Sonnet 5.5, alongside recent models like OpenAI's GPT-6 Sol and Luna, shows the market maturing. Labs are now competing on the cost-performance curve, not just on leaderboards. For a significant portion of a developer's workflow—writing unit tests, refactoring a function, generating boilerplate, summarizing a pull request—the raw intelligence of a frontier model is overkill. Latency and cost become the primary constraints.&lt;/p&gt;

&lt;p&gt;A model that is 30% faster and cheaper for 80% of your daily tasks is a material change to your workflow. It makes continuous, ambient use of AI more practical. When calling the API, you are simply targeting the new model name.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;anthropic&lt;/span&gt;

&lt;span class="n"&gt;client&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;anthropic&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Anthropic&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="c1"&gt;# api_key="my_api_key"
&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;message&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;client&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;claude-sonnet-5-5&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;max_tokens&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;1024&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;role&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;content&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Write a Python function to calculate the Fibonacci sequence and include docstrings.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;content&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This shift means you can afford to integrate AI into more granular parts of your development loop without worrying about the bill. The gains in agentic coding also suggest that mid-tier models are becoming viable for more complex automations that were previously the domain of top-tier models.&lt;/p&gt;

&lt;h2&gt;
  
  
  some gotchas
&lt;/h2&gt;

&lt;p&gt;This is not a frontier model, and Anthropic is clear about that. The company stated that Sonnet 5.5 does not advance the frontier of its models' capabilities. For high-stakes, complex reasoning, Opus 5.5 remains the recommended choice.&lt;/p&gt;

&lt;p&gt;Interestingly, because Sonnet 5.5's cybersecurity capabilities are a significant improvement over Sonnet 5, it is the first Sonnet model to ship with the kind of cyber safeguards previously reserved for top-tier models. For certain high-risk cybersecurity requests, the model will visibly fall back to Sonnet 5.&lt;/p&gt;

&lt;h2&gt;
  
  
  the so-what
&lt;/h2&gt;

&lt;p&gt;The era of just chasing the highest benchmark score is giving way to a more pragmatic focus on the right tool for the job. Sonnet 5.5 is a strong signal that the major labs see a huge market in providing capable, efficient, and economically viable models for the vast majority of software development tasks. For builders, this means more choice and better tools for the everyday grind. The most important model in your stack might not be the most powerful one, but the one that delivers reliable results with the best balance of speed and cost.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.anthropic.com/" rel="noopener noreferrer"&gt;Introducing Claude Sonnet 5.5&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>claude</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>DBRX and the Rise of Fine-Grained MoE</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Mon, 28 Sep 2026 15:04:18 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/dbrx-and-the-rise-of-fine-grained-moe-52bc</link>
      <guid>https://dev.to/albertomontagnese/dbrx-and-the-rise-of-fine-grained-moe-52bc</guid>
      <description>&lt;p&gt;A new state-of-the-art open language model just arrived, but the real story isn't just its benchmark scores. The release of DBRX provides a clear signal about where efficient model architecture is heading: fine-grained Mixture-of-Experts (MoE). For builders, this approach is the critical takeaway, as it directly impacts inference speed, serving costs, and the viability of deploying powerful custom models.&lt;/p&gt;

&lt;h2&gt;
  
  
  a new benchmark for open models
&lt;/h2&gt;

&lt;p&gt;Databricks released DBRX as a general-purpose large language model that outperforms other established open-source models on a variety of standard benchmarks, including language understanding, programming, and math. It was developed to provide enterprises with a platform to build their own custom, high-performance AI systems without relying on a few closed-source providers.&lt;/p&gt;

&lt;p&gt;The model itself is a decoder-only transformer, but its architecture is what sets it apart. This design choice is a deliberate move toward efficiency, aiming to deliver top-tier performance while managing the computational costs associated with massive models.&lt;/p&gt;

&lt;h2&gt;
  
  
  the fine-grained mixture-of-experts architecture
&lt;/h2&gt;

&lt;p&gt;The core innovation in DBRX is its fine-grained MoE architecture. Instead of a single, dense network, an MoE model comprises multiple specialized "expert" networks and a router that selects which experts to engage for a given input. While other models like Mixtral-8x7B use this approach, DBRX implements a more granular strategy.&lt;/p&gt;

&lt;p&gt;DBRX has 16 total experts and selects 4 of them for any given input. This is in contrast to models like Mixtral or Grok-1, which use 8 experts and select 2. This finer-grained approach provides a vastly larger number of possible expert combinations, which improves overall model quality. While the model has a total of 132 billion parameters, only 36 billion are active during inference on any single input. This makes the model significantly faster and more cost-effective to serve than a dense model of a similar size.&lt;/p&gt;

&lt;p&gt;This architecture is built on open-source projects, making it a design pattern that other builders can adopt. The combination of high active parameter count and a large number of fine-grained experts appears to be a key recipe for its performance.&lt;/p&gt;

&lt;h2&gt;
  
  
  running dbrx locally
&lt;/h2&gt;

&lt;p&gt;For engineers who want to experiment with the model, DBRX is available on Hugging Face. Getting it running requires the &lt;code&gt;transformers&lt;/code&gt; library and a significant amount of VRAM, but the process itself is straightforward. The model uses the GPT-4 tokenizer.&lt;/p&gt;

&lt;p&gt;Here is a basic example of how you might load the instruction-tuned model and run inference:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;transformers&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;AutoTokenizer&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;AutoModelForCausalLM&lt;/span&gt;

&lt;span class="c1"&gt;# Ensure you have torch and transformers installed
# pip install torch transformers sentencepiece
&lt;/span&gt;
&lt;span class="n"&gt;tokenizer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;AutoTokenizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;from_pretrained&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;databricks/dbrx-instruct&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="c1"&gt;# Note: This requires substantial memory. Use device_map="auto" for multi-GPU.
&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;AutoModelForCausalLM&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;from_pretrained&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;databricks/dbrx-instruct&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
    &lt;span class="n"&gt;torch_dtype&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bfloat16&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
    &lt;span class="n"&gt;device_map&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;auto&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;trust_remote_code&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="c1"&gt;# The prompt format should follow the model's chat template
&lt;/span&gt;&lt;span class="n"&gt;user_prompt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Explain the concept of a Mixture-of-Experts (MoE) model in a few sentences.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="n"&gt;messages&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
    &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;role&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;content&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;user_prompt&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="n"&gt;input_ids&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tokenizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;apply_chat_template&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;return_tensors&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pt&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;to&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;outputs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;generate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;input_ids&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
    &lt;span class="n"&gt;max_new_tokens&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;200&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
    &lt;span class="n"&gt;do_sample&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
    &lt;span class="n"&gt;top_k&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;50&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;top_p&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mf"&gt;0.95&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;response&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;tokenizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;decode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;outputs&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;skip_special_tokens&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This snippet demonstrates loading the model and tokenizer, formatting a prompt, and generating a response. The key takeaway for builders is the accessibility of a model with this architecture through standard open-source tooling.&lt;/p&gt;

&lt;h2&gt;
  
  
  why this matters now
&lt;/h2&gt;

&lt;p&gt;The release of a powerful, open model with a fine-grained MoE architecture is not just an incremental update. It's a clear indicator that the frontier of AI development is increasingly focused on architectural efficiency, not just scaling parameter counts. For engineering teams, this trend is a welcome one. Efficient models like DBRX lower the barrier to entry for building and deploying custom AI applications.&lt;/p&gt;

&lt;p&gt;This shift allows more organizations to move from proprietary, closed models to open-source alternatives that they can fine-tune and control. As builders, we should be paying close attention to these architectural patterns. They represent the next step in democratizing access to state-of-the-art AI, making powerful systems more practical and affordable to build and serve.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm" rel="noopener noreferrer"&gt;Introducing DBRX: A New State-of-the-Art Open LLM&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>machinelearning</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Gemma 2 is here. It's time to pay attention to open models.</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Fri, 25 Sep 2026 15:03:35 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/gemma-2-is-here-its-time-to-pay-attention-to-open-models-5538</link>
      <guid>https://dev.to/albertomontagnese/gemma-2-is-here-its-time-to-pay-attention-to-open-models-5538</guid>
      <description>&lt;p&gt;Google has released Gemma 2, the next generation of its open models, and it's a release that warrants a closer look from builders. The key takeaway is this: the 27B parameter model delivers performance competitive with models more than twice its size, while running on a single GPU. This isn't just an incremental update; it's a shift in the cost-to-performance ratio for high-quality open models.&lt;/p&gt;

&lt;h2&gt;
  
  
  what's new under the hood
&lt;/h2&gt;

&lt;p&gt;Gemma 2 comes in 9 billion and 27 billion parameter sizes, with a smaller 2B version also available. The architecture introduces some notable changes from the first generation. It now uses a combination of local and global attention, allowing it to focus on both immediate context and the broader meaning of a text. It also implements Grouped Query Attention (GQA) to improve inference speed and parameter efficiency.&lt;/p&gt;

&lt;p&gt;The training data for the 27B model consisted of 13 trillion tokens, while the 9B model was trained on 8 trillion tokens, sourced from a diverse mix of web documents and code. For the smaller 2B and 9B models, Google used knowledge distillation from the larger 27B model, which they report leads to significant performance gains compared to training from scratch with the same token count.&lt;/p&gt;

&lt;h2&gt;
  
  
  performance and efficiency claims
&lt;/h2&gt;

&lt;p&gt;The headline claim is that the 27B model provides a competitive alternative to much larger, closed-source models. Google states that the 9B model also delivers class-leading performance, outperforming other open models in its size category like Llama 3 8B.&lt;/p&gt;

&lt;p&gt;Crucially, the 27B model is designed for efficient inference on a single NVIDIA H100 or even an A100 80GB GPU. This significantly lowers the barrier to entry for deploying a high-performance model, moving it out of the realm of large-scale clusters and onto a single machine. This focus on efficiency makes self-hosting and running local inference for product development much more feasible.&lt;/p&gt;

&lt;h2&gt;
  
  
  how to get started
&lt;/h2&gt;

&lt;p&gt;Getting up and running with Gemma 2 is straightforward. The model weights are available on Hugging Face, Kaggle, and through Google AI Studio. For local development, tools like Ollama provide a simple way to pull and run the models with a single command.&lt;/p&gt;

&lt;p&gt;Here's a basic example of how you might run the 9B instruction-tuned model locally after installing Ollama:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Pull the Gemma 2 9B model&lt;/span&gt;
ollama run gemma2:9b

&lt;span class="c"&gt;# After pulling, you can interact with it directly&lt;/span&gt;
&lt;span class="c"&gt;# or use it via the Ollama API&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For more integrated use cases, you can use libraries like &lt;code&gt;transformers&lt;/code&gt; from Hugging Face. Here's a Python snippet to load the model and tokenizer, using 4-bit quantization to manage memory usage on consumer hardware.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;transformers&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;AutoTokenizer&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;AutoModelForCausalLM&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;BitsAndBytesConfig&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;torch&lt;/span&gt;

&lt;span class="n"&gt;model_id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;google/gemma-2-9b-it&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="c1"&gt;# Configure 4-bit quantization
&lt;/span&gt;&lt;span class="n"&gt;quantization_config&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;BitsAndBytesConfig&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;load_in_4bit&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;bnb_4bit_quant_type&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;nf4&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;bnb_4bit_compute_dtype&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;torch&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;bfloat16&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;tokenizer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;AutoTokenizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;from_pretrained&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model_id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;model&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;AutoModelForCausalLM&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;from_pretrained&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;model_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;quantization_config&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;quantization_config&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;device_map&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;auto&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;input_text&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Explain the key architectural changes in Gemma 2.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="n"&gt;input_ids&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;tokenizer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;input_text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;return_tensors&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pt&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;to&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;device&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;outputs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;model&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;generate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;**&lt;/span&gt;&lt;span class="n"&gt;input_ids&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;max_new_tokens&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;150&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tokenizer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;decode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;outputs&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This approach makes it possible to run a powerful model on a developer's laptop or a single cloud GPU, which is a game-changer for rapid prototyping and building privacy-sensitive applications.&lt;/p&gt;

&lt;h2&gt;
  
  
  the so-what for builders
&lt;/h2&gt;

&lt;p&gt;The release of Gemma 2 is another sign that the performance gap between state-of-the-art proprietary models and open models is closing, especially when you factor in efficiency. For builders, this means more freedom. You can fine-tune and deploy a capable model without being locked into a specific API provider or facing unpredictable usage bills.&lt;/p&gt;

&lt;p&gt;The ability to run a 27B parameter model that competes with 50B+ models on a single GPU is the real story here. It changes the economics of building AI features and products. It makes local, private, and cost-effective AI applications a more realistic goal for a wider range of developers and organizations. This is a good week to re-evaluate your stack and see where an open model might fit.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://blog.google/" rel="noopener noreferrer"&gt;https://blog.google/&lt;/a&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>opensource</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>MiMo-V2.6 and the bet on open reinforcement learning</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Wed, 23 Sep 2026 15:08:28 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/mimo-v26-and-the-bet-on-open-reinforcement-learning-3mn5</link>
      <guid>https://dev.to/albertomontagnese/mimo-v26-and-the-bet-on-open-reinforcement-learning-3mn5</guid>
      <description>&lt;p&gt;Xiaomi just released and open-sourced its MiMo-V2.6 series, with models positioned to compete with leading closed-source offerings on agentic tasks. But the more significant release is the methodology. The accompanying technical report details a scaled-up reinforcement learning (RL) strategy, making a public case that the path forward is not just bigger base models, but better, continuous improvement through RL at scale.&lt;/p&gt;

&lt;h2&gt;
  
  
  what changed: scaling rl in public
&lt;/h2&gt;

&lt;p&gt;The core idea behind the MiMo-V2.6 series is scaling three components of reinforcement learning in tandem: RL compute, the diversity of task environments, and grader compute. Instead of discrete training runs for different domains, the approach uses one mixed RL run across coding, general agent tasks, visual tasks, and cybersecurity. This produced two main omni-modal models: MiMo-V2.6-Pro, the flagship, and MiMo-V2.6-Flash, a smaller model optimized for cost and speed.&lt;/p&gt;

&lt;p&gt;The Pro model, a sparse mixture-of-experts architecture with over a trillion total parameters, now stands as one of the most powerful open-source models available, particularly on benchmarks that measure long-horizon engineering tasks. The company has fully open-sourced the weights and technical report for both the Pro and Flash models. They also released over 7,000 high-quality RL task environments covering software engineering, web design, and knowledge work, providing a valuable resource for others building agentic systems.&lt;/p&gt;

&lt;h2&gt;
  
  
  the engineering details that matter
&lt;/h2&gt;

&lt;p&gt;The technical report provides specific details about the training process. The RL phase consumed massive compute, processing 1,568 prompts per training step, with each prompt generating 16 attempts. This high-throughput, asynchronous training pipeline allowed the model to learn from billions of tokens at each step within a context length of up to one million tokens.&lt;/p&gt;

&lt;p&gt;A key improvement was in the quality of the feedback signal. The team moved beyond simple correctness verifiers to a more sophisticated "groupwise agentic grading" system. This grader analyzes execution traces to provide more accurate reward signals for long-running tasks, steering the model toward more token-efficient solutions. This investment in grader compute represented a significant portion of the total RL cost but was critical for keeping the training process stable and preventing reward hacking.&lt;/p&gt;

&lt;p&gt;For builders who want to run the model directly, the Hugging Face page provides configuration details. Serving the Pro model can be done using a containerized environment with a library like vLLM.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Example command to serve the model using a pre-built container&lt;/span&gt;
docker pull vllm/vllm-openai:mimov25-cu129

vllm serve XiaomiMiMo/MiMo-V2.6-Pro-RL &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--tensor-parallel-size&lt;/span&gt; 8 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--trust-remote-code&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--gpu-memory-utilization&lt;/span&gt; 0.95 &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--max-model-len&lt;/span&gt; auto &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--reasoning-parser&lt;/span&gt; mimo &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--tool-call-parser&lt;/span&gt; mimo &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--enable-auto-tool-choice&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--generation-config&lt;/span&gt; vllm
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This configuration highlights the model's native support for features like automatic tool choice, which is essential for agentic workflows.&lt;/p&gt;

&lt;h2&gt;
  
  
  the so-what for builders
&lt;/h2&gt;

&lt;p&gt;The release of MiMo-V2.6 pushes the performance of open-source models further, particularly for complex, multi-step tasks that require an agent to interact with tools and environments. On some benchmarks for long-horizon software engineering, the Pro model's performance improved significantly over the course of its RL training.&lt;/p&gt;

&lt;p&gt;While the closed-source labs are currently focused on a price war for high-volume inference, this release signals a different competitive front for open-source: the training methodology itself. By open-sourcing not just the model but also the RL environments, the release provides a toolkit for teams building their own specialized agents. It allows builders to replicate, fine-tune, and extend the RL process on their own data and tasks. This is less about providing a drop-in replacement for a commercial API and more about providing the foundation for building custom, self-improving systems.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://alphaxiv.org/abs/2409.15832" rel="noopener noreferrer"&gt;MiMo-V2.6: Scaling Reinforcement Learning Towards Self-Improvement (Technical Report)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL" rel="noopener noreferrer"&gt;MiMo-V2.6-Pro-RL on Hugging Face&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://mimo.xiaomi.com/" rel="noopener noreferrer"&gt;Introducing MiMo-V2.6 series (Official Announcement)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>machinelearning</category>
      <category>opensource</category>
    </item>
    <item>
      <title>Real-Time Translation Latency Just Dropped. Here's What Changed.</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Mon, 21 Sep 2026 15:03:44 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/real-time-translation-latency-just-dropped-heres-what-changed-42g6</link>
      <guid>https://dev.to/albertomontagnese/real-time-translation-latency-just-dropped-heres-what-changed-42g6</guid>
      <description>&lt;p&gt;Simultaneous interpretation has always been a trade-off between speed and accuracy. Waiting for more context yields a better translation, but speaking sooner reduces the awkward silence for the listener. Qwen's release of Qwen3.8-LiveTranslate suggests a change in the underlying architecture that meaningfully moves the needle, cutting average lag time to 2.3 seconds.&lt;/p&gt;

&lt;p&gt;This isn't just an incremental improvement. It's a structural change that makes real-time, multi-speaker translation practical for production applications.&lt;/p&gt;

&lt;h2&gt;
  
  
  what just shipped
&lt;/h2&gt;

&lt;p&gt;The Qwen team at Alibaba released Qwen3.8-LiveTranslate, a model for real-time, simultaneous translation of audio and video streams. It's available as a hosted API on Alibaba Cloud Model Studio and QwenCloud, accessible over a WebSocket connection.&lt;/p&gt;

&lt;p&gt;The key metric is a drop in Length-Adaptive Average Lagging (LAAL) from 2.8 to 2.3 seconds, an 18% reduction in the average time the translation trails the source speech. The model understands 60 languages and can generate speech in 29 of them.&lt;/p&gt;

&lt;h2&gt;
  
  
  the interleave architecture
&lt;/h2&gt;

&lt;p&gt;The performance gain comes from a new design Qwen calls the Interleave architecture. Previous systems often treated speech recognition, translation, and speech synthesis as separate, sequential steps. This new model reframes the problem by treating the incoming audio and the outgoing translated text as a single, interleaved data stream.&lt;/p&gt;

&lt;p&gt;Under the hood is a two-module design described as a "Thinker" and a "Talker". The Thinker module arranges the audio, source text, and translation into one causal sequence. This allows the model to process audio and generate translated text within a single, unified process, which improves both quality and latency. The Talker module then handles speech synthesis, preserving the original speaker's voice.&lt;/p&gt;

&lt;h2&gt;
  
  
  new capabilities for builders
&lt;/h2&gt;

&lt;p&gt;Beyond the latency reduction, the release includes two features that address common pain points in building real-world translation apps.&lt;/p&gt;

&lt;p&gt;First is real-time speaker diarization. The model can distinguish between different speakers in a multi-party conversation and attribute the translation correctly. The API also exposes voice cloning capabilities to maintain a more stable voice for each speaker throughout a session.&lt;/p&gt;

&lt;p&gt;Second is a synchronized bilingual display. The API can stream both the source transcription and the translation as separate, aligned events. This allows you to build UIs that show both languages simultaneously, which is critical for applications like subtitling or meeting summaries where users might need to reference the original text.&lt;/p&gt;

&lt;p&gt;Here is a conceptual look at how you might handle the WebSocket stream in Python.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;asyncio&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;websockets&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;

&lt;span class="c1"&gt;# Note: This is a conceptual example. 
# Refer to official Alibaba Cloud documentation for the actual API endpoint and auth.
&lt;/span&gt;
&lt;span class="n"&gt;WEBSOCKET_URI&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;wss://api.qwen.ai/v1/translate/qwen3.8-livetranslate-flash-realtime&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;stream_audio_for_translation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;audio_chunk_iterator&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;websockets&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;connect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;WEBSOCKET_URI&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;websocket&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Connection established.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;send_audio&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
            &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;chunk&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;audio_chunk_iterator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;websocket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;chunk&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;asyncio&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;sleep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c1"&gt;# Simulate real-time streaming
&lt;/span&gt;            &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;websocket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;send&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;dumps&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;event&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;stream_end&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}))&lt;/span&gt;

        &lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;receive_translation&lt;/span&gt;&lt;span class="p"&gt;():&lt;/span&gt;
            &lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;message&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;websocket&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                &lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;loads&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;event&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;transcription&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;SOURCE: &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;event&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;translation&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;TRANSLATION: &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                &lt;span class="k"&gt;elif&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;event&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;error&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
                    &lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Error: &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;message&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
                    &lt;span class="k"&gt;break&lt;/span&gt;

        &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="n"&gt;asyncio&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;gather&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;send_audio&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt; &lt;span class="nf"&gt;receive_translation&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;

&lt;span class="c1"&gt;# Example usage:
# async def get_audio_chunks():
#     # Your logic to get real-time audio chunks from a mic or stream
#     for i in range(10):
#         yield f"audio_chunk_{i}".encode('utf-8')
#
# asyncio.run(stream_audio_for_translation(get_audio_chunks()))
&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  so what
&lt;/h2&gt;

&lt;p&gt;For engineers who have previously dismissed simultaneous translation as too slow or inaccurate for interactive use cases, this release is a signal to re-evaluate. The architectural shift from a sequential pipeline to an interleaved stream is a meaningful change. When combined with practical features like speaker separation, it makes building robust, multilingual, real-time voice applications significantly more feasible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://www.alibabacloud.com/blog/qwen3-8-livetranslate-names-the-speaker-carries-the-meaning_602166" rel="noopener noreferrer"&gt;Qwen3.8-LiveTranslate: Names the Speaker. Carries the Meaning.&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://modelstudio.aliyuncs.com/models/qwen/qwen3.8-livetranslate-flash-realtime/summary" rel="noopener noreferrer"&gt;Alibaba Cloud Model Studio: qwen3.8-livetranslate-flash-realtime&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>machinelearning</category>
      <category>python</category>
      <category>news</category>
    </item>
    <item>
      <title>Mistral just shipped a vision model and cut flagship prices</title>
      <dc:creator>albe_sf</dc:creator>
      <pubDate>Fri, 18 Sep 2026 15:02:31 +0000</pubDate>
      <link>https://dev.to/albertomontagnese/mistral-just-shipped-a-vision-model-and-cut-flagship-prices-3o6i</link>
      <guid>https://dev.to/albertomontagnese/mistral-just-shipped-a-vision-model-and-cut-flagship-prices-3o6i</guid>
      <description>&lt;p&gt;Mistral just made two significant moves that position it as an increasingly practical alternative to the major closed-source labs. The company released Pixtral, a new vision model, and simultaneously announced a price reduction for its flagship model, Mistral Large 2. This isn't just a routine update; it's a clear signal about their strategy: compete directly on multimodal features while aggressively pushing down cost.&lt;/p&gt;

&lt;h2&gt;
  
  
  what just shipped
&lt;/h2&gt;

&lt;p&gt;The update, which appeared on their official changelog on September 17, included three key changes.&lt;/p&gt;

&lt;p&gt;First, the release of &lt;code&gt;pixtral-12b-2409&lt;/code&gt;, their new vision model. The naming suggests a 12-billion parameter model, a deliberate choice to offer strong performance in a cost-effective, easily deployable size. This follows a broader industry trend toward multimodality, but Mistral's commitment to open and efficient models makes this release particularly notable for builders.&lt;/p&gt;

&lt;p&gt;Second, they released an updated version of their small model, &lt;code&gt;mistral-small-2409&lt;/code&gt;. While less flashy than a new vision model, continuous improvement of smaller, efficient models is critical for production use cases where latency and cost are primary constraints.&lt;/p&gt;

&lt;p&gt;Third, Mistral cut the price on their most capable model, Mistral Large 2, and introduced a free API tier on their platform, La Plateforme. This directly addresses one of the biggest barriers to adoption for smaller teams and individual developers: cost. Lowering the price of your top-tier model is a confident move designed to capture more production workloads.&lt;/p&gt;

&lt;h2&gt;
  
  
  competing on cost and capability
&lt;/h2&gt;

&lt;p&gt;The release of Pixtral is a direct answer to the multimodal models from larger labs. For developers building applications that need to understand or process images, this provides a new, potentially more open and efficient option. While benchmarks are not yet available, a 12B parameter model is large enough for serious tasks without incurring the inference costs of massive frontier models.&lt;/p&gt;

&lt;p&gt;Integrating a model like this into a workflow is straightforward. You can expect to interact with it through the standard API, likely with a modified payload to handle image inputs, such as a base64-encoded string or a URL.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;requests&lt;/span&gt;
&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;base64&lt;/span&gt;

&lt;span class="n"&gt;API_KEY&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;YOUR_MISTRAL_API_KEY&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="n"&gt;MODEL_NAME&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;pixtral-12b-2409&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;

&lt;span class="c1"&gt;# Encode a local image file
&lt;/span&gt;&lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="nf"&gt;open&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;path/to/your/image.jpg&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;rb&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;as&lt;/span&gt; &lt;span class="n"&gt;image_file&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;encoded_string&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;base64&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;b64encode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;image_file&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;read&lt;/span&gt;&lt;span class="p"&gt;()).&lt;/span&gt;&lt;span class="nf"&gt;decode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="s"&gt;utf-8&lt;/span&gt;&lt;span class="sh"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;headers&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Authorization&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Bearer &lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;API_KEY&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Content-Type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;application/json&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;data&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;model&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;MODEL_NAME&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;messages&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;role&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;content&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
                &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Describe the contents of this image in detail.&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;
                &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;image_url&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;image_url&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;url&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;data:image/jpeg;base64,&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;encoded_string&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}}&lt;/span&gt;
            &lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;response&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;requests&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;post&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;https://api.mistral.ai/v1/chat/completions&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is more than just adding a feature. It's about providing the core building blocks that engineers need. The simultaneous price cut on Mistral Large 2 reinforces this. It makes the entire stack, from small and efficient to large and powerful, more economically viable. For teams running systems at scale, these cost differences add up quickly.&lt;/p&gt;

&lt;h2&gt;
  
  
  the bigger picture: open distribution
&lt;/h2&gt;

&lt;p&gt;Mistral's strategy appears to extend beyond just models and APIs. Their recent partnership with Mozilla to integrate Mistral models into the Firefox browser is a move to control distribution and reach users outside of the typical developer-focused cloud platforms. By building a presence directly in the browser, they are creating a new channel for their technology, one that is built on a foundation of open technology.&lt;/p&gt;

&lt;p&gt;This matters. As AI becomes more deeply embedded in our daily tools, the question of who controls the underlying models becomes critical. By partnering with organizations like Mozilla and continuing to release open-weight models, Mistral is providing a real alternative to the closed ecosystems of Big Tech.&lt;/p&gt;

&lt;p&gt;For builders, this is a positive development. It means more choice, better pricing, and the ability to build on platforms that align with the open principles of the web. The latest releases are not just new tools, but a continued investment in an ecosystem that offers more than one way to build.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://docs.mistral.ai/changelog" rel="noopener noreferrer"&gt;Mistral AI Docs: Changelog&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>opensource</category>
      <category>machinelearning</category>
    </item>
  </channel>
</rss>
