Subscribe, if this was forwarded to you

Hey there,

This week, we’re looking at faster AI infrastructure, visual retrieval, and more reliable agent workflows. Cerebras’ new CS-4 promises up to 30× faster inference, PixelRAG brings visual context into web-scale retrieval, and our featured tutorial shows how to build a GPT-style LLM from scratch in PyTorch.
We’ll also explore Best-of-N verification, NVIDIA’s 100% ARC-AGI-3 score, AI outperforming expert humans at persuasion, and the latest research on context engineering and multi-agent security.

Enjoy the read!

Cheers, Andreas & Sascha

In today's edition:

📚 Tutorial of the Week: Build a GPT LLM from Scratch

🛠️ Tool Spotlight: PixelRAG: Visual Retrieval for Web Content

📰 Top News: Cerebras CS-4: 30× Faster AI Inference

💡 Tip: Best-of-N Agent Verification with LLMs

Let's get started!

Tutorial of the week

Build a GPT-Style LLM from Scratch in PyTorch

Using an LLM is easy. Understanding what actually happens underneath the API is much harder. Sebastian Raschka’s open-source LLMs-from-scratch project takes a code-first approach to that problem, walking you through the complete process of building, pretraining, and fine-tuning a GPT-style language model in PyTorch.

• Build the complete pipeline: Work through tokenization, embeddings, attention, transformer architecture, pretraining, instruction fine-tuning, and text classification.

• Learn by implementing: Each chapter comes with well-documented Jupyter notebooks, Python scripts, exercises, and solutions rather than hiding the details behind high-level libraries.

• No massive GPU cluster required: Much of the material runs on standard laptops, while the code automatically takes advantage of GPU acceleration when available.

• Go beyond the basics: Additional material covers LoRA, Mixture-of-Experts, memory-efficient weight loading, and adapting the implementation to architectures such as Llama, Qwen, and Gemma.

• Understand rather than just use LLMs: By implementing the components yourself, you get a much clearer mental model of how modern language models actually work.

If you’ve mostly worked with LLMs through APIs or frameworks and want to understand what happens one level deeper, this is one of the best hands-on resources available.

Tool of the week

PixelRAG — Visual Retrieval-Augmented Generation for the Web

Traditional RAG pipelines usually strip a webpage down to text before indexing it—discarding layout, tables, charts, and other visual context in the process. PixelRAG takes the opposite approach: it indexes screenshots of web content directly, allowing multimodal models to retrieve information based on both meaning and appearance.

The result is an 18% improvement over conventional text-based RAG methods, according to the project’s benchmarks.

• Pixel-native retrieval: Web pages, PDFs, and images are rendered into screenshot tiles, preserving visual structure that text extraction often loses.

• Multimodal search: Query the index using either text or images, making it possible to retrieve content based on how it looks as well as what it says.

• Modular tooling: The pixelshot and pixelrag CLIs handle rendering, embedding, indexing, and serving, with FAISS and Qdrant supported as vector backends.

• Claude Code integration: PixelRAG includes a plugin that lets Claude Code retrieve and reason over visual web content directly.

• Web-scale out of the box: The project provides a pre-built index covering 8.28 million Wikipedia pages, alongside a hosted API and local deployment options.

PixelRAG is an interesting example of how multimodal models can change RAG architecture itself—not merely add image support on top of a text-first retrieval pipeline.

Top News of the week

Cerebras CS-4 Promises 30× Faster AI Inference at Wafer Scale

Cerebras has unveiled the CS-4, its latest rack-scale AI system built around three WSE-3 Turbo wafer-scale processors. The company claims the system can deliver up to 30× faster inference than traditional GPU-based infrastructure, while targeting some of the largest AI workloads currently possible.

The numbers are substantial. CS-4 delivers 250 PFLOPS of compute, 43.2 PB/s of memory bandwidth, and wafer-to-wafer latency as low as 2 microseconds. Cerebras says the system can generate more than 1,000 tokens per second for models exceeding 10 trillion parameters, while delivering up to 10× more throughput per watt than its CS-3 predecessor.

The system is built around Cerebras’ modular Nexus rack architecture, combining three WSE-3 Turbo wafers into a platform designed for easier deployment and maintenance. Initial shipments are expected to begin this quarter.

If Cerebras can deliver these numbers consistently in real-world workloads, CS-4 could make interactive inference practical even for models that are far beyond the scale typically served on conventional GPU clusters.

🔗 Read the official announcement

Mind Viruses Can Spread Between AI Agents

A new study explores how self-propagating ideas—dubbed “mind viruses”—can spread through networks of interacting LLM agents and potentially carry harmful behavioral instructions with them. Susceptibility varies significantly across models, prompts, and network structures, but the researchers report an encouraging result: a simple warning added to the system prompt provided near-total protection in their experiments.

🔗 Read the arXiv paper

AI Out-Persuades Human Experts—and Nearly Triples Donations

Across almost 19,000 conversations, frontier AI models proved more persuasive than professional canvassers, competitive persuasion tournament winners, and world-champion debaters. Even after humans received targeted coaching, the AI systems retained their advantage. In one particularly striking result, AI was almost 3× more effective than professional canvassers at increasing real-money donations to Save the Children.

🔗 Explore the full study

OpenAI Slows Frontier Training Over Cybersecurity Capabilities

OpenAI has temporarily slowed reinforcement-learning work on its most capable frontier models after its upcoming Astra model approached critical cybersecurity capability thresholds. The company is using the pause to strengthen research-environment security, expand monitoring, and conduct additional red-team evaluations before resuming more advanced training workloads.

🔗 OpenAI’s announcement

NVIDIA AVO Scores 100% on ARC-AGI-3

NVIDIA’s Agentic Variation Operators (AVO) architecture completed all 183 levels of the ARC-AGI-3 public set, achieving a perfect score. Rather than relying purely on a stronger base model, AVO combines persistent memory, supervision, and tool use—making the result an interesting demonstration of how agent architecture itself can dramatically improve performance on long-horizon tasks.

🔗 Read the technical blog

Context Engineering: 96% Still Haven’t Reached Maturity

A Redis-sponsored survey finds a striking gap between belief and implementation: 73% of respondents say agents fail more often because of broken context than broken models, yet only 4% report having mature, compounding context systems in production. Most organizations are still struggling with shared infrastructure, freshness, governance, and reliable context delivery.

🔗 Read the full report

Tip of the week

Improve Agent Reliability with Best-of-N Verification

When an agent produces an important answer, why trust its first attempt?

Best-of-N verification takes a simple approach: generate several candidate solutions, evaluate them against explicit criteria, and select the strongest result. This trades additional inference cost for higher reliability—especially useful for coding, reasoning, and other tasks where correctness matters more than latency.

• Generate multiple candidates: Instead of accepting a single trajectory, let the agent attempt the problem several times.

• Score each result: The open-source LLM-as-a-Verifier framework uses another LLM to judge candidates against criteria you define.

• Automatically pick the best: The verifier scores each candidate and returns the strongest solution.

• Customize what “best” means: Evaluate correctness, completeness, safety, style, or any other task-specific requirement.

Install the verifier with:

pip install llm-verifier

A minimal example:

import llm_verifier

problem = "Write a function that reverses a string."

candidates = [
    "def rev(s): return s[::-1]",
    "def rev(s): return s",
    "def rev(s): return ''.join(sorted(s))",
]

result = llm_verifier.select(
    problem=problem,
    candidates=candidates,
    criteria={"Correctness": "Does the code actually reverse the string?"},
)

print(result.index)
print(result.scores)

Best-of-N verification is particularly useful for high-value agent tasks where spending a little more inference compute is worthwhile if it significantly increases the chance of getting the right answer.

Explore the LLM-as-a-Verifier framework

We hope you liked our newsletter and you stay tuned for the next edition. If you need help with your AI tasks and implementations - let us know. We are happy to help