Agent Atlas

Field notes

The Builders

The people getting the most out of coding agents mostly use the same tools you can get today. What sets them apart is how they arrange them: where the agents run, how many at once, how they check the work, and how they spend a limited allowance. Here is what they say they do, in their own words, with the date they said it.

Who they are

Factual
26 builders, grouped by what they make. Open anyone for their setup.

Open anyone for their setup, how they work, and the habits they share with the others.

They ship products and sites

They make content and teach

They build the tools

They make films, games and music

The shape of a serious setup

Simplified
One always-on box runs the agents; the models are rented.

David Heinemeier Hansson's setup as of October 2026. The model is rented. The machine that matters is a small box that never sleeps.

Youlaptop or phonedecide, review
Tailscaleit rings you
The shedmini PC, always onagents in Herdr or tmuxthe code, the builds, the tests
API calls
ModelsClaude, GPTin the cloud
The agents live on an always-on machine on his Tailscale network (David Heinemeier Hansson on X). A Minisforum MS-A2, though he says a cheaper Beelink will do (David Heinemeier Hansson on X). The laptop can be weak and its lid can close (David Heinemeier Hansson on X). No models run locally (David Heinemeier Hansson on X). Herdr keeps sessions alive when the client disconnects (herdr) and rings when an agent needs him (Lex Fridman Podcast).

The gear shelf

Factual
Every machine they name, with price, specs and how many agents it runs.

Every machine a builder here names, cheapest first, with who uses it and the maker's page. Photos are free-licensed and credited. None of this is required: a laptop and a $20 plan is a real start.

Hetzner VPS

Hetzner VPS

A rented server. Levels quotes $7 a month and runs Claude Code on his, next to the sites.

From
€5.99–16.99 a month (Hetzner; Hetzner)
Base
2 vCPU, 4 GB. The €5.99 plan was sold out on Nov 14.
Runs
1–2 light agents. Not a Mac mini: a quarter of a base mini's memory, shared CPU, no screen. Fine for scripts, sites and APIs.

Pieter Levels

Maker's page →Photo: Jöeg Frister, CC BY 3.0
Mac mini

Mac mini

Small, quiet, always on. Two M4 Pro minis sit in Jeffrey Emanuel's fleet.

From
$899 (Apple; Apple)
Base
M6, 12-core CPU, 16 GB
Runs
4–6 agents, with builds. Ours is the 8 GB M1, measured below.

Jeffrey Emanuel

Maker's page →Photo: Seasider53, CC BY 4.0

Prices checked November 14, 2026. Memory shortages have pushed several up this year; follow the links. “Runs” is our estimate, explained in the next section.

How much machine you need

Estimate
The model runs in the cloud. Your box only runs the agents and what they build. Sized by plan, from $0 to $200 a month.

A coding agent on your machine is a small program that sends text to a model in a data center and runs commands on your code. The thinking happens elsewhere. What your machine pays for is everything the agent starts: builds, test runs, browsers, dev servers.

Measured on this site's own machine

Agent Atlas is built on an 8 GB M1 Mac mini (Apple). On November 14 it had 18 Claude Code processes open, using 1,360 MB together: 58 MB for a typical one, 307 MB for the busiest. Codex and Grok added 220 MB. Building this site peaked at 435 MB, and a full run of its browser tests at 1,950 MB. The agents are cheap. Their work is not. In daily use it slows down once two or three agents are building at once.

Our measurement, one afternoon, one machine. Read it as a size, not a benchmark.

A rule of thumb

Leave about 4 GB for a desktop system, or 1 GB for a server with no screen. Then budget about 2 GB for each agent that builds and tests at the same time, more for one that drives a browser. Claude Code itself asks for 4 GB of RAM or more (Anthropic), and OpenAI recommends 8 GB for Codex (OpenAI).

4 GB server

1–2 agents

A small VPS. Light builds; browser tests will crawl.

8 GB desktop

2 agents

Like ours. It works, and it swaps.

16 GB

4–6 agents

A base Mac mini. The sweet spot for one person.

32 GB

10 or more

Room for browsers, dev servers and a second vendor.

64 GB and up

Local models too

Agents stop being the limit. The model you load is.

By what you spend on models

Your plan limits how many agents you can keep busy long before your machine does. Match the box to the plan.

$20 a month

The laptop you have

One agent at a time, while the lid is open. Claude Pro is $20 a month (Anthropic), ChatGPT Plus $20 with Codex included (OpenAI). Your five-hour window runs out before your memory does.

Hardware: $0

$40 a month

Two plans, two vendors

Claude Pro and ChatGPT Plus. One agent builds, the other reviews, and when one plan's window runs out you switch. Two or three agents at once is the ceiling, set by the plans. An 8 to 16 GB machine is enough: this site's 8 GB mini slows after two or three. A $5–17 VPS runs one or two light ones; it is not a Mac mini.

Hardware: what you have, or a base Mac mini at $899

$100–200 a month

One box that never sleeps

Claude Max is $100, Ultra $200 (Anthropic); ChatGPT Pro comes at $100, $200 or $500 (OpenAI). That buys several agents working most of the day. Put them on a 16 to 32 GB machine at home: a Mac mini at $899 (Apple) or a Beelink with 32 GB at $929 (Beelink). Or rent one: 8 vCPU and 16 GB is €59.49 a month at Hetzner (Hetzner). Add Tailscale, tmux or Herdr, and a bell.

Hardware: about $900–1,300 once, or €60 a month

$200–400 a month

The power user: two big plans, a big box

Claude Ultra and a $200 ChatGPT Pro, side by side: ten or more sessions through the day, one vendor building and the other checking. Give it 32 GB or more. DHH's MS-A2 takes up to 96 GB (Minisforum), and Jeffrey Emanuel runs a room of machines (Jeffrey Emanuel). Spend on memory before cores.

Hardware: $1,300–2,500, or two boxes

What none of these does is run the frontier models themselves. Those take data-center chips: see the Machine Room and Will it fit? for local models.

Under the agents

Simplified
Eight layers serious builders add: network, sessions, bell, search, memory, secrets.

The model is rented. Everything around it is yours to set up. These are the layers serious builders end up with, what they use, and the cheapest way to get each one yourself.

  1. A box that never sleeps

    DHH runs most agents on a mini PC on his network, Levels on rented Hetzner servers, Emanuel on a room of Linux boxes. (David Heinemeier Hansson on X; Pieter Levels; Jeffrey Emanuel)

    Your own: A spare computer, a mini PC, or a rented server. A small VPS keeps one or two agents awake; it is not a Mac mini. See how much machine you need.

  2. A private network

    Tailscale joins DHH's shed, Steinberger's two Macs and Levels' servers. (David Heinemeier Hansson on X; Peter Steinberger; Pieter Levels)

    Your own: Put every machine on one tailnet, and expose nothing to the open internet.

  3. Sessions that outlive the connection

    tmux keeps a terminal running after you disconnect. Levels opens one per site. DHH uses Herdr. (tmux; Pieter Levels; herdr)

    Your own: Start agents inside tmux, so closing the laptop or losing signal stops nothing.

  4. A bell

    Boris Cherny gets a system notification when a session needs him. Herdr rings DHH. (Boris Cherny on X; Lex Fridman Podcast)

    Your own: ntfy sends a push to your phone from one line of script. (ntfy)

  5. Search

    Agents need the live web. Most builders use the search built into their agent.

    Your own: SearXNG is a metasearch engine you can host yourself, and agents can call it like an API. (SearXNG)

  6. A page reader

    Search finds a page. Something has to turn it into clean text the model can read.

    Your own: Jina Reader does it with one URL prefix. Crawl4AI is an open-source crawler you run yourself. Playwright drives a real browser for pages that need one. (Jina AI; Crawl4AI)

  7. A memory of past sessions

    Emanuel's cass searches the coding-agent sessions saved on the machine. (Jeffrey Emanuel)

    Your own: Start with the transcripts your harness already saves. See the Tool Shelf.

  8. Secrets out of the code

    Keys live in the environment, never in the repo. (Adam Wiggins)

    Your own: One env file outside the repo, readable only by you, and no key ever pasted into a prompt.

Build your own search-and-read server

Our sketch of the service many builders end up with. Simplified: no one recipe is standard.

  1. Pick the always-on box and put it on your private network.
  2. Run SearXNG in a container for search.
  3. Run a crawler or a headless browser that fetches a page and returns Markdown.
  4. Put a small web service in front with two calls, search and read. Require a token, and cache what you fetch in SQLite or Postgres so the same page is not fetched twice.
  5. Be a good guest: an honest user agent naming your project, a rate limit, and each site's terms.
  6. Tell your agents in one line of AGENTS.md: the address, the header, and when to prefer it over built-in search. The token stays in your env file.

Start where you are

Pick your budget, get the next three steps.

Pick the one that fits. The steps are our advice, drawn from the builders below. The plan rules under the picker come from the companies' own pages.

Your laptop. Claude Pro or ChatGPT Plus, with Claude Code or Codex in the terminal.

  1. Your first message starts the five-hour clock. Send it when you sit down, not when you first glance at your phone.
  2. One task per session. Clear when the task is done, so the agent stops re-reading old work.
  3. Keep the instruction file short. It is read on every reply.
  4. Use the smaller, faster model for small jobs. It stretches the same allowance much further.
  5. Work on medium effort. Drop to low while you steer, and raise it when the agent checks its work.
  6. Spread the week. The weekly limit is the one you cannot wait out in an afternoon.

Skip for now: Chatting about the plan in one app and building in another. Both count against the same allowance.

Your day in five-hour windows

Simplified
Your plan
8:0013:0018:0023:00

Start at 8:00 and keep working, and you open up to 4 windows before midnight. Each resets five hours after the message that opened it. The weekly limit still caps the total.

  • Paid Claude plans have a session limit that resets every five hours, plus a weekly limit. The five hours start with your first message (Anthropic).
  • Chat and Claude Code share one allowance (Anthropic). Claude Pro is $20 a month billed monthly, and the $200 plan has no five-hour limit (Anthropic).
  • Codex has a free tier for quick tasks. ChatGPT Plus at $20 includes Codex in the terminal, the editor and the web, measured in five-hour periods with weekly limits on top (OpenAI).
  • Model choice matters more than anything else you control. OpenAI's own estimate for Plus runs from about 5 messages per five hours on its largest model to about 3,000 on its smallest (OpenAI).
  • Long sessions cost more than they look. Every reply re-reads the whole conversation. See Plate IV.

Plan rules checked November 11, 2026. Plans change; check the linked pages.

The loop they share

Different people, different tools. The same five moves keep showing up.
  1. Plan

    Agree on the plan before any code. Boris Cherny starts most sessions in plan mode (Boris Cherny on X).

  2. Run in parallel

    Several agents, each on its own task, with a bell when one needs you. Five terminal tabs for Boris (Boris Cherny on X), about sixteen threads across machines for DHH (Lex Fridman Podcast).

  3. Verify

    Give the agent a way to check its own work: tests, a browser, evals for your product. Boris ranks this first (Boris Cherny on X). Hamel Husain and Shreya Shankar teach it (Hamel Husain and Shreya Shankar).

  4. Second opinion

    Another model reviews the work. DHH writes with Claude and calls Codex his favorite checker (Lex Fridman Podcast).

  5. Write it down

    Agents forget. Files do not. Mistakes go into the instruction file (Boris Cherny on X), progress into files the next run reads (Geoffrey Huntley), tasks into a graph on disk (Steve Yegge). See Plate II.

The small tweaks

Factual
Their rules and settings, where they agree and where they split.

The rules and settings they put in their instruction files and terminals. Each line is the person's own, with where they said it.

Several of them do this

Found on more than one person's own page. The pages do not cite each other.

Give the agent a way to check its work, and do not take "done" for an answer.

  • Boris Cherny: Calls a way to verify the most important thing. (Boris Cherny on X)
  • Kelvin Wang: Runs the tests, looks at the screen, or asks which command ran. (Kelvin Wang)

An agent that says it finished may not have. A test, the real screen or the command it ran will tell you.

Clear the conversation between tasks.

  • Kelvin Wang: /clear before switching to an unrelated task. (Kelvin Wang)
  • Jesse Vincent: /clear the implementer after each task, never /compact. (Jesse Vincent)

The next task starts with none of the last one's context.

Have a different model check the work.

  • David Heinemeier Hansson: Writes with Claude. Codex is his favorite checker. (Lex Fridman Podcast)
  • Paweł Huryn: Hands the prompt or code to the runtime that did not write it. (Paweł Huryn)

In Huryn's words, a different model has different misses.

Review the plan before the agent edits anything.

  • Boris Cherny: Starts most sessions in plan mode, shift+tab twice. (Boris Cherny on X)
  • Kelvin Wang: Spec, then plan, then a review, before anything runs. (Kelvin Wang)
  • Amelia Wattenberger: Reads, edits and approves the drafted spec before agents start. (Amelia Wattenberger)

Kelvin says the agent's options may not include the approach that fits you best.

When the agent gets something wrong, write the correction into the instruction file.

  • Boris Cherny: His team adds a line to the shared CLAUDE.md each time. (Boris Cherny on X)
  • Kelvin Wang: Records decisions in CLAUDE.md for every later session. (Kelvin Wang)

The next session already knows, so you stop repeating yourself.

Where they disagree

Two careful people, opposite habits.

How much effort, or thinking, should the model spend?

  • Boris Cherny: Medium about 95% of the time. Xhigh or max for complex visual work. (Boris Cherny on X)
  • Thariq Shihipar: Implements on low, reviews, then verifies on high. Switches mid-conversation with /effort. (Thariq Shihipar)
  • Paweł Huryn: High for small daily tasks, max for the hardest. Max fixed 33 of 105 bugs where high fixed 13. (Paweł Huryn)

More effort costs more of your allowance and time. Too little and the agent misses things.

Two agents on one repo, a worktree or a fresh checkout?

  • Jesse Vincent: A git worktree for each new task. (Jesse Vincent)
  • Simon Willison: No worktrees yet. A fresh checkout, often in /tmp. (Simon Willison)

Agents working in the same folder trip over each other's changes.

Approvals stay on, or go off when it is safe?

  • Boris Cherny: Never skips permissions. Pre-allows the bash commands he knows are safe. (Boris Cherny on X)
  • Simon Willison: YOLO mode, no approvals, only when malicious instructions cannot reach the context. (Simon Willison)

Approving every command is slow. Skipping them all lets a hostile instruction run.

One person's habit

Worth a try. Only one builder here says it.

Put rules with no exceptions in a hook or a permission rule.

  • Kelvin Wang: Hooks and permission rules for hard rules; CLAUDE.md for the rest. (Kelvin Wang)

The model reads CLAUDE.md and may not follow it. A hook runs every time.

Agents write what they found back into the spec.

A stale spec misleads agents that do not know better.

Turn reasoning down on a local model.

  • Simon Willison: Low or no reasoning in LM Studio, not the default. (Simon Willison)

At its default setting, he says, Qwen 3.8 27B wildly over-thinks.

One rules file for every agent.

  • Kelvin Wang: ~/.claude/CLAUDE.md imports one AGENTS.md, which Codex also reads. (Kelvin Wang)

Claude Code and Codex follow the same rules, and he edits them in one place.

A short human opener, then the agent's PR essay folded away.

  • Simon Willison: The agent's text goes inside a details and summary element. (Simon Willison)

Nobody reads a long agent-written description. The opener is what he vouches for.

Keep CLAUDE.md under 200 lines.

  • Kelvin Wang: Under 200 lines, only what the code cannot tell the agent. (Kelvin Wang)

He says the longer the file, the less reliably it is followed. Leave out what the code already says.

Turn what you do many times a day into a slash command.

He stops retyping the same prompt many times a day, and the commands live in git.