Weeknotes: F1 Data Analysis, and an Autonomous Agent Called Gravel
F1 is in full swing now and the F1 Picks 2026 prediction game has become a testing ground for two different ways of working with agents.
F1 Picks: Data Analysis
Last year I went down the ML route - built a model by the end of the season, inspired by some podcasts I did and a genuine interest in ML. Honest assessment: it was probably overfitted and didn’t add much.
This year I’ve shifted to data exploration. The 2026 regulation changes mean limited historical data anyway, and the game rules changed, so a fresh approach made sense.
The analysis notebook use the Hungarian algorithm for optimal driver allocation - use each driver exactly once across 22 races, classic assignment problem. It pulls data from OpenF1 and FastF1, builds an expected points matrix, adjusts for current form, and solves the allocation.
The whole thing is built collaboratively with a coding agent. I steer - use this algorithm, weight data this way, adjust for sprints - the agent implements. It’s also writing a picks diary, documenting its reasoning and reviewing its own analysis each week.
Gravel: Full Autonomy
I wanted to see what happens when you take yourself out of the loop entirely. Same game, same data sources, but the agent makes every decision.
Gravel is a fully autonomous F1 picks agent. Built with the Claude Agent SDK - my first time building my own agent loop with it, which was interesting in itself.
The architecture is straightforward. Gravel gets an MCP server for interacting with the F1 Picks website directly - full autonomy around making and reviewing picks. It also has the ability to pull F1 data, look at practice and qualifying results, use notebooks for analysis, and search for news and betting odds via Exa. The prompting nudges it towards structured analysis but doesn’t prescribe methodology.
I run it twice per race weekend: once just before qualifying when all the free practice data is in, and once afterwards for reflection. Sprint weekends adjust accordingly.
Both runs feed into a diary - Gravel’s persistent memory. It records what decisions it made, why, what data it considered, and what it got right or wrong. This gives it history and continuity across the season.
It’s been a good contrast with the collaborative approach. With the analysis notebook, I steer and the agent drives. With Gravel, the agent does both. Different feedback loops, different levels of control, same problem domain.
Building with the Claude SDK
This was my first time using the Claude SDK directly rather than working through Claude Code or another harness. A few things stood out.
Unlike rolling your own agent loop, the tools come from Claude Code itself - Bash, file operations, notebooks. You bridge domain-specific capabilities via in-memory MCP servers, and the SDK wires everything into the agent loop. You give it a system prompt with the constraints and context, and let it loop.
It also works with your Claude Max plan, which makes running it regularly viable without worrying about API costs.
The SDK sits underneath Claude Code, so understanding it gives you a better mental model of what’s happening when you use the higher-level tools.
What I’ve Been Learning From
Links, reads, watches, and listens from the week.
Articles:
- Why ATMs didn’t kill bank teller jobs, but the iPhone did - automation doesn’t always displace, sometimes it reshapes
- NanoClaw Docker Sandboxes - container-based sandboxing for AI agent execution
- Your LLM Doesn’t Write Correct Code - why generated code needs verification, not blind trust
- This CSS Proves Me Human - the small creative choices in CSS that AI doesn’t replicate
- AINews: The high-return activity of raising your aspirations for LLMs - Latent Space on agent infrastructure, MCP debates, and raising ambitions for what LLMs can do
- AINews: Context Drought - Latent Space on why context windows haven’t grown past 1M and the memory shortage behind it
Podcasts/Videos:
- Taylor Otwell at Laracon EU - self-healing Laravel app live on stage, the full autonomous loop
- Dylan Patel — Bottlenecks to Scaling AI Compute - Dwarkesh Patel on the hardware and supply chain constraints limiting AI scale
- The Most Important Question About AI - Dwarkesh Patel on what matters most as AI capabilities advance
- From IDEs to AI Agents with Steve Yegge - Pragmatic Engineer on the shift from traditional IDEs to agentic development
- Daniel Bourke — Fine-tuning SLMs for iPhone - getting small language models running on-device
- Pragmatic AI: The Education Business in an AI World - Jeffrey Way on education when AI can teach
- State of Agentic Coding #4 - Armin Ronacher and Ben on the current state of coding with agents
The season will tell which approach produces better picks - but honestly, the picks are almost secondary. The interesting part is watching how an autonomous agent builds intuition over time through its diary, versus a human-steered agent that benefits from domain knowledge but is bottlenecked by attention.
