Python

Why Are We Still Hand-Writing Prompts?
How Can Tiny Rules Build Complex Worlds?
A Prompt Is Not Yet a Program
Build Your First Automaton
Define the Contract
Encode All 256 Elementary Rules
Rule 30 and the Surprise of Complexity
Build Programs From Programs
Rule 110 and Computation in a Grid
Conway's Game of Life
Examples Are Experimental Data
Patterns as Data — Oscillators, Spaceships and Gliders
You Cannot Optimize What You Cannot Measure
Beyond Conway — Life-like and Multi-State Rules
Memory and Selective Recall
Add Randomness Without Losing the Model
Build a Forest Fire Simulation
Simulate Traffic with Rule 184
Diffusion as Local Exchange
Reaction-Diffusion and Pattern Formation
Build a Predator-Prey Ecosystem
Generate Caves from Noise
Grow Terrain from Local Height Rules
Generate Textures with Local Rules
Measure a Cellular Automaton
Activity, Density and Change
Entropy and Information
Periodicity and Attractors
Sensitivity to Initial Conditions
Classify Rule Behavior
Search All 256 Elementary Rules
Search Larger Rule Spaces
Evolve Rules for Desired Behavior
Cellular Automata as Computation
From Discrete Cells to Continuous State
Neighborhoods as Convolution Kernels
Growth Functions
Build Lenia From First Principles
Discover Your First Lenia Organisms
Search Lenia Parameter Space
Multi-Kernel and Multi-Channel Lenia
Damage, Robustness and Persistence
Flow-Lenia and Mass-Conserving Artificial Life
Make the Automaton Differentiable
Learn the Local Update Rule
Hidden Cell Channels and Local Memory
Grow a Target From One Seed
Randomize the Update Schedule
Train for Persistence
Regenerate After Damage
Test Generalization Beyond Training
Neural Cellular Automata for Pathfinding
Learn to Solve Mazes
Generalize to Harder and Larger Mazes
Inspect Hidden-State Propagation
What Did the Neural CA Actually Learn?
Profile Before You Optimize
Vectorize the Update Loop
Run Cellular Automata on the GPU
Build a Reusable Cellular Automata Engine
Make Experiments Reproducible
Build a Cellular Automata Laboratory
Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation
Advanced Agents From First Principles 06: Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture
Advanced Agents From First Principles 05: Is One Model Doing Everything? Build a Mixture of Experts at the Agent Level
Advanced Agents From First Principles 04: Does Your Agent Prune Good Ideas Too Early? Use Monte Carlo Tree Search for Long-Horizon Reasoning
Advanced Agents From First Principles 03: Does Your Agent Commit to a Bad Reasoning Path Too Early? Build a Tree of Thoughts
Advanced Agents From First Principles 02: Why Does My Reasoning Agent Give a Different Answer Every Time? Use Self-Consistency Without Confusing Consensus With Truth
Advanced Agents From First Principles 01: Does Your AI Agent Fail on Complex Reasoning Tasks? Treat Chain of Thought as Computation, Not Proof
Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?
Agents From First Principles 09: AI Agent Says It Worked When It Didn’t? Verify the Result Outside the LLM
Agents From First Principles 07: AI Agent Forgets Previous Work? Add Working, Semantic and Episodic Memory
PyTorch Tensor Shapes: Broadcasting, Reshape, View, Permute and the Errors That Waste Your Time
DeepResearch Part 1: Building an arXiv Search Tool with SmolAgents