The Pydantic AI Server

Excited to introduce the Pydantic AI Server as a brand new framework to tackle one of the biggest painpoints of productionising multi-agent systems! This new framework allows you to basically wrap your Pydantic AI agents without doing any changes - as always best to show an example, say you have your agent:

# agent_file.py
from pydantic_ai import Agent

my_agent = Agent(
    model="test",
    instructions="You are a helpful assistant.",
    defer_model_check=True,
)

@my_agent.tool_plain
def greet(name: str) -> str:
    """Say hello to someone."""
     return f"Hello, {name}!"

Install pydantic-ai-server[cli] and run your agent:

pais agent run agent_file:my_agent

And we can deploy to our multi-agent network using KAOS:

pais agent deploy agent \

    --image <registry>/agent:v1 \

    --build agent_file:my_agent --push \

    --modelapi my-api \

    --model gemini/gemini-flash \

    --sub-agent <your-other-subagents>

With a few commands you now can enable your agent with HTTP API (w SSE support), conversation memory, remote tool dispatch, multi-agent delegation, observability, etc - as well as direct deployment to Kubernetes! Check it out, and if you want to support, do share, star or add an issue!

Visual Intro to PyTorch

The fastest way to level up your ML knowledge is by learning the fundamentals, and this is a great visual intro to the PyTorch core components: When using PyTorch you can get started with a minimum surface area to build and train a small model end-to-end. This deep dives starts with tensors as the core abstraction, shows how real inputs reduce to numeric tensors, then builds intuition for autograd, and finishes with a small "production-shaped" training example on tabular house-price data. This is quite a good example as it provides the standard workflow with split train/test, defining an nn.Module MLP with ReLU activations, train with an explicit loop using Adam + MSE, switch to model.eval() and torch.no_grad() for inference, de-normalize predictions for human-readable metrics (MAE/MAPE), and save weights via state_dict(). It is always great to dive back into the fundamentals to ensure your knowledge doesn't get rusty.

The Good Open Source AI List

If you're building ML systems in 2026, Chip Huyen released an actively updated list of the top and fastest growing AI open source projects sorted by category and sub-category, super useful: The Good AI List is updated daily as a leaderboard for tracking what's trending in open-source AI on GitHub indexing ~15K repos / ~150K developers. I really like how it is possible to find the fastest growing projects with 1-day and 7-day star deltas, which shows right now there's a massive explosion of accelerated popularity for repos across the board. For production ML practitioners, the practical value is triage and discovery, we can use it to spot fast-moving infra (agent runtimes, sandboxes, orchestration, RAG plumbing), emerging "skills/prompt" ecosystems, and tooling that’s gaining real adoption signals. If you haven't this is definitely a resource that is worth checking out and bookmarking for reference as well.

New Python Sandbox for AI

Pydantic is dropping a new rust-based Python interpreter specifically built for LLM/Agent execution, this "codemode" space is definitely an interesting area to keep an eye on: Monty is an open-source Python "bytecode" VM written in Rust that's built with security by design as a sandbox environment. The key idea is "start from nothing, then allowlist capabilities" - it seems that Monty code has no filesystem, network, env var access by default, and the only way it can touch the outside world is via external functions you explicitly expose, which are the tools you'd normally register for tool-calling. This is inspired from Anthropic's code mode, which allows for an execution environment that allow agents chain commands. It is also interesting that in this case the Python VM is optimized for speed, with sub-millisecond startup times, and low processing costs, together with good old Pydantic type checking. It is quite exciting to see non-cpython based implementations of Python, as this is definitely going to spark quite a lot of innovation in the space.

Sebastian Raschka's 8th Chapter

Sebastian Raschka is at it again with his (WIP) Manning book "Build A Reasoning Model", and is sharing for free the working code and exercises, which are an absolute goldmine: This week he released the 8th "bonus" chapter with a practical data-gen pipeline for knowledge distillation of reasoning models. Basically given a JSON of math problems + ground-truth answers, it generates teacher outputs (both a thinking trace and a final answer) and writes them incrementally to a new JSON dataset you can use to train a smaller reasoning model. This is really interesting as it allows us to turn expensive/slow reasoning into something that we can ship and explore on smaller models with low latency / less costs to get them to perform. Definitely worth checking out.

The Institute for Ethical AI & Machine Learning is a European research centre that carries out world-class research into responsible machine learning.

✉️ Email, 🐦 Twitter, 💼 Linkedin