[October 2026] AI & Machine Learning Monthly Newsletter 🤖

81st issue! If you missed them, you can read the previous issues of my monthly A.I. & Machine Learning newsletter here.

Hey everyone!

Daniel here, I’m a machine learning engineer who teaches the following beginner-friendly machine learning courses:

• Complete Machine Learning and Data Science Bootcamp: Zero to Mastery
• TensorFlow for Deep Learning: Zero to Mastery
• PyTorch for Deep Learning: Zero to Mastery
• [NEW] 🤗 Machine Learning with Hugging Face Bootcamp: Zero to Mastery

I also write regularly about machine learning on my own blog as well as make videos on the topic on YouTube.

Since there's a lot going on, the utmost care has been taken to keep things to the point.

Here's what you might have missed in October 2026 as an A.I. & Machine Learning Engineer... let's get you caught up!

My Work

• Advice for junior engineers: start the job before you have it — A short video reacting to Felix Rieseberg’s post on junior engineers (see below). My advice for a junior: if you’ve already done a few foundational courses, skip the next one, pick a real problem and build a working prototype of it, then iterate and learn along the way.

From The Internet

• Two posts from Felix Rieseberg, a hiring manager at Anthropic:
  • How to be more ambitious: A tutorial for humans with models by Felix Rieseberg — Felix splits being ambitious with AI into four types, Speed, Altitude, Depth and Range, with prompts for each.
  • Hunger beats tenure: Advice for junior engineers by Felix Rieseberg — Felix dropped the coding interview for his team and gives five pieces of advice for junior engineers, from picking business impact over the backlog to building your idea over a weekend. He gives the example of two relatively new engineers who built a working prototype of a graphical interface for Claude Code over one weekend, with the first public version shipping roughly eight days later. “I’m seeing engineers who are comparatively new fly past people who are probably better coders and have been around much longer. Hunger beats tenure.”
• A PR on modded-nanogpt cuts training time by 83% — A very cool technique to use the CPU to train an n-gram model and so the predictions now become as much a retrieval problem as they do a generation problem. While the language model trains on the GPU, the CPU builds a longest exact-match retrieval index over 37B tokens. The exact matches are passed to the language model as hints, taking the time to train nanoGPT on 8x H100 from 40.5 seconds to 6.7 seconds (about 6x faster).
• Managing frontier model training organizations (or teams) by Nathan Lambert — An article from March 2025 which still rings true today. It provides recommendations and failure modes for running LLM training teams. I like the experimentation point on LLMs: about 80% or more of Tülu 3’s experiments were at the 8B scale and the project evaluated about 1,000 checkpoints. And the quote: “A lot of the sexy work is not that helpful and a lot of the useful work isn’t sexy. Data is the prime example as the often most impactful type of work.”
• Two resources from Hugging Face on post-training agents:
  • The ultimate guide to multi-harness RL — Why the same model scores differently in different agent harnesses (Claude Code, Codex, OpenCode and others), plus an open framework for RL training a model inside unmodified harnesses. They show an example of LFM2.5-2.6B trained across four harnesses going from solving 42% of held-out tasks to 54%.
  • A curriculum for post-training agents — A five-step reading and watching path: SFT, distillation, RL, RL environments, then harnesses and scale. Each step comes with a diagram, a livestream or slides, a blog post and the matching TRL trainer (e.g. GRPOTrainer for RL).

• [Video series] Building Reasoning Models from the Ground Up: A Full Video Course by Sebastian Raschka — Eight free coding videos (over 11 hours) which take a pre-trained Qwen3 0.6B model and add evaluation, inference-time scaling, reinforcement learning and distillation in Python and PyTorch. It accompanies his book Build a Reasoning Model (From Scratch).
• MPS in PyTorch 2.15 — PyTorch 2.15 sees significant improvements for Apple silicon users (MPS = Metal Performance Shaders), including FP8 tensors, much faster mixture of experts (MoE) decoding and many ops moved to dedicated Metal kernels. For example, compared to 2.14, Qwen3.6-35B-A3B decodes at 61.3 tokens/s instead of 9.4 tokens/s on an M3 Ultra.
• Cloudflare introduce Clairic, a new System One class of extraction models — A preview model on Workers AI which pulls typed values (text spans, numbers, dates, lists) out of text and images, and estimates numbers with 80% intervals, in a single forward pass without generating tokens. They combine two types of system-one models in a damaged-product claims pipeline, running Clairic and Clef (Cloudflare’s decision model) before GLM-5.3 took 19.3 seconds end to end instead of 61.7 seconds and cost 49% less per million claims. A good quote from the article explains when to use what: “Extraction models turn raw input into typed values, decision models turn values into decisions, and LLMs turn decisions into words.”

• Datadog introduce Scout 1.0, a model specialized for SRE (Site Reliability Engineering) investigations — Datadog’s first in-house model is a GLM-5.3 Flash checkpoint post-trained with reinforcement learning in investigation simulations built from real incidents and it now powers their Bits AI SRE agent. Datadog say Scout 1.0 medium matches GPT-6.1 Sol high and Claude Opus 5.5 high at 3 to 8x lower estimated inference cost. See the full technical report for more.

• comma.ai release openpilot 0.11.2 — The new update swaps the FastViT-T12 (small model, 12M parameters) vision backbone for a ConvNeXt XL (big model, 349M parameters), adds a 4B parameter world model and RL post-training for the driving policy. The big model runs on chestnut, comma’s PCIe-to-USB bridge which connects a desktop GPU to the comma four. The new model has about 15x the parameters of the small model in 0.11.1 and uses about 55x the compute.

Open Source

Vision

• NVIDIA RADIO v3 and v4 vision encoders in timm — 12 timm ports (standard ViT and variable-size NaFlexViT) of NVIDIA’s C-RADIOv3 and C-RADIOv4 image encoders. The v4 versions combine SAM3, SigLIP2 and DINOv3 features into one backbone through multi-teacher distillation. C-RADIOv4-SO400M (413.5M parameters) gets 55.14 mIoU on ADE20k compared to 52.75 for the larger C-RADIOv3-H (632.0M parameters).
• Tencent release WeVisOne-VL — Apache 2.0 VLMs (2B and 4B) built on Qwen3-VL which handle detection, referring, counting, pointing, OCR, segmentation and matting by writing coordinate tokens. On dense detection, the 4B model gets 71.3 mean F1 compared to 58.3 for Rex-Omni-3B and 15.2 for Qwen3-VL-4B. See the paper for more. Some of my notes:
  • Task formulation: treat object detection, segmentation, counting and referring expression as next token prediction tasks. One of the most important topics in LLM creation is task formulation.
  • Takes the hidden state of each <OBJ> token and predicts pixel-level items (along with the predicted box and the model’s own vision features, no SAM required).

• OpenLVD-200M dataset — 197.7M web image URLs with alt-text captions, selected from COYO-700M, DFN-2B and Re-LAION-5B using DINOv3 embeddings and hierarchical k-means, for training and distilling vision foundation models. Used in the SigLino paper by the Technology Innovation Institute (TII).

LLMs + VLMs

• Mistral release Mistral Large 4 — A multimodal (text and image input) MoE with about 1T total parameters and 49B active per token, 1M token context and a modified MIT license (Model-as-a-Service businesses need a separate license). It scores 48% on the Artificial Analysis Coding Agent Index, effectively tied with GLM-5.3 (49%) while using 47% fewer tokens per task on average. See the model card for weights.

• Meta release Muse Spark Open — Meta’s open-weight MoE with 816B total and 42B active parameters, text, image, audio and video input, 1M token context and a focus on agentic coding. The NVFP4 version runs on a single B200 node, while BF16 needs four nodes of 8 H200s. All 256 experts stay in memory, so it needs the memory of an 816B model but runs at the speed of a 42B one. See the model card for full details.
• NVIDIA release Nemotron 3.5 models — Open models under the OpenMDW-1.1 license, from a 4GB on-device model to a 120B VLM.
  • Bolt E4B 4GB (small) — A text model post-trained from Gemma-4-E4B-it for low-latency local assistants, scoring 82.40 on IHEval compared to 66.61 for Gemma 4 E4B-it.
  • Bolt 74B-A9B (medium) — A VLM compressed from Super VL, with a 24GB version (native 2-bit) for running locally.
  • Super VL 120B-A12B (NVFP4) — A hybrid Mamba-2, MoE and attention VLM with 1M context which fits on a single DGX Spark or H200.
  • Nemotron 3.5 Parse (document parsing) — A ~0.6B document image parser which outputs text with layout classes, bounding boxes and reading order. On ParseBench it scores 75.20 at 10.62 pages/s compared to 75.10 at 2.76 pages/s for LightOnOCR-3-4B.
• DeepSeek-V4.1-Flash-1017 — An update to last month’s DeepSeek-V4.1-Flash, still MIT licensed, with improvements across reasoning, coding, agentic tasks and vision. Benchmark-wise, on DeepSWE it goes from 74.2 to 77.0 and ProgramBench from 20.3 to 29.1.
• Liquid AI release LFM3 — Six open-weight 2B-class models (text, vision, audio, omni and two decision models) all trained from one LFM3-1.7B base under the LFM Open License v1.0. LFM3-1.7B runs in ~1 GB of memory at 4-bit and scores 38.42 on WebArena-Verified compared to 3.02 for LFM2.5-2.6B.
  • Another highlight: Liquid d1-2B — Open weights for Liquid AI’s decision model (covered last month), built on LFM3-VL-2B. It replaces d1-3B and takes 5.7 ms per decision on an H100.
• Recursive release Flint — Apache 2.0 text-only MoE coding model with 39.8B total and about 2.5B active parameters, trained from scratch by a small team in under four months. It scores 54.9% on Terminal-Bench 2.1 compared to 44.9% for Qwen3.6 and runs at more than 125 tokens per second on an M4 Pro MacBook Pro (see the blog post).

Embeddings and Retrieval

• UltraBERT: One Encoder for Classification and Retrieval — Apache 2.0 English encoders (150M and 380M) with 32K context from DMIS Lab, trained with a mix of low and high masking ratios. The 380M model gets 91.0 on GLUE and 47.7 on BEIR compared to 90.4 and 45.2 for ModernBERT 395M. Quote on the data setup: “Low masking wins classification, high masking wins retrieval.”
• Google DeepMind release EmbeddingGemma 2 — An Apache 2.0 embedding model which puts text, code, images, video and audio into one 768-dimension space, with about 740M parameters (the text-only part is 270M). On MMEB-v2 it scores 59.01 compared to 43.61 for jina-embeddings-v5-omni-nano. Even cut down to 128 dimensions, it beats every other sub-1B model running at full dimensionality. See the paper for more.

• Octen release Octen-WebGR — Generative retrieval for navigational web search: a 4B model (and a 0.6B version) generates the ID of the right URL out of 195.9M real pages, so the index lives in the model’s weights. It gets 59.6 hit@1 compared to 24.8 for dense retrieval and 9.1 for BM25. Weights are CC BY-NC 4.0 (non-commercial).
• Ai2 release OlmoEarth v1.3 — A satellite embedding model which turns a year of radar and multispectral imagery into a 128-dimension vector for every 10-meter pixel on Earth, with open weights, pretraining data and code. Ai2 also share precomputed annual embeddings for the whole planet and a browser-based Embeddings Explorer for finding similar places or training a small classifier from a few labeled points. The 128-dimension embeddings score highest on 20 of 27 evaluations against AlphaEarth Foundations and Tessera v2.

Image Generation

• Black Forest Labs release FLUX 3 Image Klein — A 5.6B parameter open-weights model for text-to-image, image editing and multi-reference generation, free for commercial use under $5M annual revenue. With the distilled model and INT8 build, it generates a 1MP image in about 4 seconds on an RTX 5090.

• OpenMOSS release MOSS-Image-SFT — An Apache 2.0 text-to-image model built on a 5B diffusion transformer trained from scratch, aimed at dense English and Chinese text rendering and layout control with bounding boxes. See the paper for more.

Agents

• Google’s Agent Development Kit (ADK) — An open-source (Apache 2.0) framework for building, evaluating and deploying agents in Python, TypeScript, Go, Java and Kotlin. ADK 2.0 adds graph-based workflows which mix deterministic code with LLM steps. Below is a small example of a nutrition workflow: an LLM step breaks a meal description into foods and a plain Python function matches them to a nutrition database.

from google.adk import Agent, Workflow
from pydantic import BaseModel

class Food(BaseModel):
    name: str
    grams: float

class Meal(BaseModel):
    foods: list[Food]

# LLM step: free text in, a structured breakdown out
breakdown_agent = Agent(
    name="breakdown_agent",
    model="gemini-3.8-flash",
    instruction=(
        "Break the meal the user describes into foods, "
        "each with an estimated weight in grams."
    ),
    output_schema=Meal,
)

# Deterministic step: match each food to a nutrition database
NUTRITION_DB = {  # values per 100 g
    "banana": {"calories": 89, "protein": 1.1},
    "greek yogurt": {"calories": 59, "protein": 10.2},
    "rolled oats": {"calories": 379, "protein": 13.2},
}

def match_to_database(node_input: Meal) -> dict:
    totals, unmatched = {"calories": 0.0, "protein": 0.0}, []
    for food in node_input.foods:
        per_100g = NUTRITION_DB.get(food.name.lower())
        if per_100g is None:
            unmatched.append(food.name)
            continue
        for key in totals:
            totals[key] += per_100g[key] * food.grams / 100
    totals = {key: round(value, 1) for key, value in totals.items()}
    return {"totals": totals, "unmatched": unmatched}

# The agent's Meal output becomes the function's node_input
root_agent = Workflow(
    name="nutrition_agent",
    edges=[("START", breakdown_agent, match_to_database)],
)

# Run it on a meal
import asyncio
from google.adk.runners import InMemoryRunner

async def main():
    runner = InMemoryRunner(agent=root_agent)
    events = await runner.run_debug(
        "A banana, 50 g of rolled oats and 170 g of greek yogurt", quiet=True
    )
    for event in events:
        if event.output:
            print(f"{event.author}:{event.output}")

asyncio.run(main())

# Output:
# breakdown_agent: {'foods': [{'name': 'banana', 'grams': 118.0},
#     {'name': 'rolled oats', 'grams': 50.0},
#     {'name': 'greek yogurt', 'grams': 170.0}]}
# nutrition_agent: {'totals': {'calories': 394.8, 'protein': 25.2},
#     'unmatched': []}

Releases

• Google releases Gemini 4 Carbon — Google’s new frontier model for long-horizon agentic work and cyber defense, building on Gemini 4 Argon from two weeks earlier at the same price ($2 per million input tokens, $10 per million output tokens). It scores 54.8% on ExploitGym compared to 42.4% for GPT-6 Astra. It scores 59 on v5 of the Artificial Analysis Intelligence Index, putting it 1 point ahead of Claude Opus 5.5. Note: At the time of writing, Gemini 4 Carbon is not publicly available yet.

Papers and Research

• LLM-as-Jev: LLMs Are Already Jev-Style Decision Models — Reads Jev-style decisions (a probability over numbered options) straight from an ordinary LLM’s next-token probabilities, plus a recipe for when fine-tuning helps. With no training, Qwen3.5-4B correctly answers 188 of the 231 public JevBench items (81.4%), matching community Jev-style models on the same backbone.

• Google Research Harness² — Improves an agent by editing its harness (prompts, guardrails, memory, skills, subagents) while keeping the model weights fixed, carrying lessons from task to task. One Harness² step gives gains of up to 11.5 points on WorkBuddy-Bench and 11.8 percentage points on LAB. See the paper for more.
• A Fix for Softmax and Cross-Entropy — Google DeepMind researchers show standard softmax, log-softmax and cross-entropy have two floating-point bugs which zero out gradients once a model gets confident, and give drop-in fixes. Without weight decay, standard cross-entropy’s test accuracy collapses from 61% to 23% at the fp32 precision cliff while the fixed version keeps going to 85%.

Videos

• Is the Agent Harness Dead? by Jediah Katz (SpaceXAI) at AI Engineer — Jediah worked on Cursor’s agent harness and argues models have absorbed what harnesses used to add for coding, through a data flywheel, while harnesses still open up new kinds of tasks and handle long-running infrastructure, security and efficiency. It’s a little bit of cat and mouse here. A model eats up functionality of a harness and then a new harness gives the model extended functionality until that too eventually gets absorbed by the model.
• How Revolut Cut AI Coding Costs 90% With Self-Hosted Open Models by David Abitbol at AI Engineer — A case study on how Revolut self-hosts GLM-5.3 on 56 B200 GPUs for about 2,000 engineers, at a blended cost of 30 cents per million tokens, one tenth of their previous bill with Anthropic and OpenAI. Tuning inference settings rather than adding GPUs took time to first token from over 10 seconds to about 1.6 seconds.

Misc

• Coinbase fine-tune Qwen3.5-9B for fraud prevention — Coinbase CEO Brian Armstrong on X/Twitter: a Qwen3.5-9B model fine-tuned on internal data outperformed frontier models on a fraud prevention task, and employees now have an internal skill to fine-tune and serve their own models. Against an Opus 4.5 decision agent, recall went up 12.0 percentage points with median latency of 0.683 seconds instead of 1.515 seconds.

See you next month!

What a massive month for the AI/ML world in October!

As always, let me know if there's anything you think should be included in a future post. In the meantime, keep learning, keep creating, keep dancing.

See you next month,

Daniel

www.mrdbourke.com | YouTube

By the way, I'm also an instructor with Zero To Mastery Academy teaching people Machine Learning & AI in the most efficient way possible. You can see a few of our courses below or check out all Zero To Mastery courses.