Jimenez et al. · arXiv · 2023
SWE-bench: Can Language Models Resolve Real-World GitHub Issues?
The benchmark every serious agent is measured against — read it once and the leaderboards stop being mysterious.
Resources
What we read so you don’t have to.
Watchfire doesn’t exist in a vacuum — it sits on top of years of research and engineering on coding agents, sandboxes, and the protocols that connect them. This is the short, opinionated list of papers, posts, projects, and talks that have actually shaped how we think. If you’re trying to decide whether to take agents seriously, start here.
Foundational reading on AI coding agents.
The papers and posts we point new contributors at — benchmarks, agent design, and a couple of survey-style essays that age unusually well.
Anthropic Engineering · 2024
Building effective agents
Anthropic's plain-language taxonomy of agent patterns — the post most other agent posts are quietly remixing.
Anthropic Engineering · 2025
Claude Code best practices
Concrete guidance from the team that ships Claude Code — most of it generalises cleanly to any agent CLI.
Yang et al. · arXiv · 2024
SWE-agent: agent-computer interfaces enable software engineering
Princeton's paper on how the shape of the agent's tool surface — not just the model — drives task success.
Aider · ongoing
Aider LLM leaderboards
Practical, code-edit-focused benchmarks updated as new models ship — closer to the work most operators actually do.
martinfowler.com · ongoing
Exploring Gen AI
Martin Fowler and friends, writing slowly and carefully about agents in real engineering teams — a counterweight to the hype feeds.
Anthropic · 2024
Introducing the Model Context Protocol
The announcement that turned tool-use from per-vendor bespoke wiring into something you can actually compose. Worth re-reading after each major release.
Simon Willison · 2024
LLMs in 2024
Simon Willison's year-end stocktake — the single best 10,000-foot view of where coding agents actually landed last year.
Aider · 2024
Aider — benchmarking SWE-bench Lite
The post that made it obvious how much of "agent skill" is actually editor mechanics — pairs well with the SWE-agent paper.
Backend agent CLIs.
The six command-line coding agents Watchfire drives today. Each card links to the project’s own home plus the Watchfire page explaining how it’s wired up here.
Anthropic
Claude Code
Anthropic's CLI coding agent — the original Watchfire backend.
OpenAI
Codex
OpenAI's Codex CLI — long-running coding sessions with isolated homes.
Open source
opencode
Open-source coding agent — bring your own provider.
Google
Gemini CLI
Google's Gemini coding agent on the command line.
GitHub
GitHub Copilot CLI
GitHub Copilot from the command line, running in yolo mode behind the sandbox.
Anysphere
Cursor Agent
Cursor's headless agent CLI — distinct from the in-editor agent.
See the full backend comparison on the agents page.
Related open-source projects.
The orchestration, sandboxing, and TUI projects in Watchfire’s extended family — some we depend on, some we just learn from.
Sandboxing
Bubblewrap
The unprivileged Linux sandbox Watchfire uses to fence each agent run on Linux — a single static binary doing a lot of namespace work.
Landlock
Linux's unprivileged access-control LSM — the building block that makes per-process filesystem policies possible without root.
Apple App Sandbox design guide
Apple's reference for the `sandbox-exec` policy language Watchfire targets on macOS — the canonical source for what the seatbelt actually does.
Dev containers
Dev Containers specification
The open spec for repo-pinned development environments — the closest thing the wider industry has to Watchfire-style per-project setup.
devcontainers/spec
The source repo for the Dev Containers spec — read the issues to see how the rest of the ecosystem reasons about reproducible agent environments.
Protocols
Model Context Protocol
The protocol Watchfire's secrets and integrations story will lean on more and more — agent-to-tool wiring you only have to learn once.
gRPC
The transport between `watchfired` and every Watchfire client. The official docs are still the fastest way to understand what we're getting from it.
TUI building blocks
Bubble Tea
The Elm-inspired TUI framework the Watchfire CLI/TUI is built on — read the README before you read our terminal code.
Lipgloss
The styling layer that makes Bubble Tea apps look like Bubble Tea apps — including ours.
Adjacent agents
OpenHands
An open-source SWE-bench-grade autonomous coding agent — useful to skim if you want to see a very different shape from the Watchfire model.
SWE-agent
The Princeton-NLP agent that gave the SWE-bench paper its teeth — small surface, very readable code.
Talks & podcasts.
The audio and video corner is intentionally short — we only list things we’ve actually finished. This section is in progress; if you have a favourite, tell us in Discussions.
Dwarkesh Podcast · 2024
Sholto Douglas & Trenton Bricken on the Dwarkesh Podcast
Two researchers from Anthropic on where models are actually getting better — useful context for why coding agents kept improving through 2024–25.
Latent Space · ongoing
Latent Space — the AI engineer podcast
The interview feed that has, for several years, talked to almost everyone shipping coding agents — start with whichever episode covers a backend you use.
Pragmatic Engineer · 2024
The Pragmatic Engineer on AI coding tools
Gergely Orosz's survey of how engineering teams are actually adopting agents — practical, evidence-led, low on hype.
From the Watchfire blog.
A few of our own posts that pair well with the reading list above — cost, mode picking, sandbox design, and what we learned dogfooding the thing on itself.
What it costs to run Watchfire
11 min
Watchfire itself is free, but every task it runs spends real money against an agent backend. Here is a practical, numbers-forward breakdown of what each backend costs, which mode burns the most, and three concrete ways to stay under a monthly budget.
Which mode when? A practical guide to Chat, Task, Start-all, and Wildfire
8 min
Six agent modes is one more than you can hold in your head when you are staring at the GUI for the first time. Here is a practical, opinionated decision tree for picking the right one without burning a session.
How Watchfire sandboxes every agent run
10 min
Worktrees stop an agent from stomping on your branch, but they will not stop it from reading your SSH key. Here is the OS-level sandbox layer that does, and how Watchfire picks the right backend on each host.
Watchfire eats its own dogfood: how this website is built by the thing it documents
8 min
Every page, every blog post, every illustration on watchfire.io was shipped by a Watchfire task running in an isolated worktree. Here's what we learned from one hundred and thirty sessions of running the tool on the tool.
Why we run every task in its own git worktree
9 min
Every Watchfire task runs in its own git worktree on a dedicated branch, not in a fresh checkout of the main tree. Here is why that choice carries more weight than it looks.
Anatomy of a great task: how to write prompts coding agents actually finish
10 min
Most failed agent runs aren't model failures — they're prompt failures. After a year of running Watchfire on itself, here's what we've learned about writing tasks an agent can actually complete on the first try.
More on the blog index.
Got a suggestion?
This page is a living curation, not a definitive list. If a paper, post, or talk changed how you think about coding agents, send it our way — we read every one.
Or drop a note in /community if you’d rather say hi first.