How to run AI coding agents for longer without babysitting them

The first thing you notice when you run an AI coding agent like Claude Code is how often it stops. Not because the work is finished. It’s waiting on you. It wraps up a task and goes quiet. It hits a command that needs a yes and just sits there. It runs low on context and starts going in circles. Every one of those pauses is a moment the agent could be working but isn’t, and the thing it’s waiting on is you.

Here’s the good news. Keeping an agent busy for hours isn’t about a smarter model. It’s about taking away the things that make it stop. There are four of them, and each one has a fix.

Why does the agent keep stopping?

An agent that’s “running” is really just looping: read the task, make a change, check it, then ask for the next thing. It stalls at the seams of that loop.

• It ran out of work. You gave it one task. It finished. Now it’s idle, waiting for you to think of the next one.
• It’s waiting on a yes. It wants to run a command or edit a file, and your permission settings make it ask first. Step away from the keyboard and it waits forever.
• It’s working alone. One agent does one thing at a time. However big your to-do list is, you’re capped at a single agent’s pace.
• It ran out of context. Long sessions fill the context window. The agent forgets what it decided an hour ago, repeats itself, or quietly gets worse.

Fix all four and the agent goes from working in little bursts to running for hours while you check in now and then. Let’s take them one at a time.

Keep it fed with a backlog

The dumbest reason an agent stops is that there’s nothing left in the queue. You hand it tasks one at a time, so the second it finishes, it sits idle until you come up with the next thing.

Write the list down where the agent can read it. That’s the whole trick.

crystl’s Workbench does this with a plain WORKBENCH.md file at your project root. A drawer slides out from the edge of the terminal and shows the list as tickable checkboxes, but the real source of truth is that markdown file, so your agent reads and writes the exact same list you do. Queue up five tasks, tell it to work the list, and it pulls the next item itself instead of waiting for you to spell it out.

## To Do
- [ ] Wire up the /login route
- [ ] Add rate limiting to the auth endpoints
- [ ] Write integration tests for the payment flow
- [ ] Update the changelog

Because the backlog is just a committed file, it survives restarts and hands cleanly between sessions. Come back tomorrow and the agent picks up the same list it left.

Stop making it wait on you

The single biggest source of dead time is the permission prompt. By default your agent asks before it edits a file or runs a command. That’s exactly what you want when you’re watching it. It also means the moment you walk away, it freezes on the first action that needs a yes.

Two things fix this.

First, auto-approve the safe stuff. crystl’s approval modes let you decide how much the agent can do on its own. Smart mode waves through read-only operations like file reads and greps, and only stops you for actual changes, so it never freezes on the dozens of harmless lookups it does between edits. Auto mode approves everything for a small, trusted task. You set this globally or per project, so a throwaway prototype can run wide open while your production repo stays careful. Honestly, smart mode is the one to start with. It kills most of the waiting without giving the agent a blank cheque.

Second, answer the rest from your pocket. Even in smart mode, the agent will eventually hit something that genuinely needs your call. If that happens while you’re out, it waits. Unless you can answer from wherever you are. The crystl mobile app pairs to your Mac and pushes the agent’s questions and approval requests straight to your phone. You get pinged, you tap allow or deny, and it keeps going. A coffee run stops being a hard stop for every agent you’ve got running.

Between auto-approving the harmless operations and answering the rest from your phone, the agent almost never sits there waiting for a human who isn’t in the room.

Run more than one

One agent can only do one thing at a time. If your backlog spans the frontend, the API, and the tests, even your fastest single agent grinds through them in order. The way past that ceiling is to run a few at once, and that only works if they don’t trample each other’s files.

crystl gives you two ways to do it.

Fanout, where one session runs the team

Fanout turns one Claude session into a manager for a whole team of agents. You hand it a freeform list of tasks and it figures out which project each one belongs to, spins up a worker for each, looks after them, and merges the finished work back when they’re done. Looking after them means handling their approvals and answering their questions for you.

/fanout fix the login bug in webapp; add tests to the api; update the changelog in docs

Instead of babysitting five agents in five tabs, you talk to one manager that runs the other five. Workers aimed at the same project each get their own isolated git worktree so they can’t clobber each other, and the manager only comes back to you when something actually needs your judgment. This is how a backlog gets chewed through in parallel without you running the show by hand.

crystl Quest, a coordinated party

crystl Quest runs a party of agents on one project toward a shared goal. Each gets a role (frontend, backend, tests, review) and a chat channel they talk through. Quest hands your instructions to the agents one at a time so each sees what the last one did, which keeps them from duplicating work. In sealed mode, every agent gets its own worktree branch. In open mode, they share a directory for work you can cleanly carve up.

Reach for Fanout when you’ve got a list of jobs to farm out and want one session quietly managing the workers. Reach for Quest when the agents need to actually coordinate with each other. Quest also has an answer to the context problem, which is the last thing on the list.

Don’t let context run out, hand it off

Every long session eventually fills the context window. The agent’s memory gets fuzzy, it forgets decisions, and the quality slides. For a solo agent the fix is housekeeping: get it to write down what it’s decided and what’s left before it runs out, so a fresh session can pick up clean.

crystl Quest does this for you. A party can include a Healer, a lightweight agent whose whole job is to watch everyone else’s remaining context and step in when one starts running low. It automatically writes compressed summaries, handoff notes, and a record of what’s been settled, so the quest survives any single agent hitting its limit. The important stuff lives in files, not in one agent’s head. The same idea works for a solo session too: get the plan out of the agent’s memory and into a file, and a restart costs you nothing. There’s more on this here.

Putting it together

Running an agent for the long haul comes down to four habits:

• Queue the work so there’s always a next task. That’s a backlog file the agent reads right alongside you.
• Auto-approve the safe operations and answer the rest from your phone so it isn’t stuck on a human who walked off.
• Parallelize with Fanout or a Quest party when one agent’s pace isn’t enough.
• Get the plan out of context so a token limit forces a handoff, not a restart from scratch.

None of this needs a different agent. It’s the same Claude Code (or Codex, or Gemini) you already run, with the things that make it stop taken off the table. crystl is a macOS terminal built around exactly that: keeping one agent, or a team of them, working while you supervise instead of babysit.