What an autonomous coding agent does alone, and what it still asks you

An autonomous coding agent takes a ticket to a pull request by itself

An autonomous coding agent takes a ticket, plans the change, edits the code, runs the tests and opens a pull request with nobody watching, the stage Swarmia calls Level 3. Inside, it runs a loop. It breaks the goal into steps, works through them with a terminal, a file editor and a test runner, reads each failure and tries again until the suite passes. Then it hands the diff to a person as a pull request and answers the review comments.

A copilot in your editor is a different tool. It suggests the next line while you type and stops when you stop. An autonomous coding agent gets the whole task and comes back later with a branch. The AI coding agents landscape sorts the current tools along that split, the ones that work beside you and the ones that run on their own.

I run agents this way every day, and I worry about the code least. My time goes to the moments when an agent needs a person and nobody is looking.

Autonomy is a dial with five settings

Swarmia's framework splits coding agent autonomy into five levels, from inline suggestions in one file to orchestrators that spawn their own subagents, and the article's own title says higher isn't always better. I'd read it before any tool list, because each level says where the person sits.

Swarmia compares choosing a level to staffing. An industry expert stuck in an intern's job is wasted, and a middle-schooler in the CEO chair is a disaster. A Level Up Coding essay goes further and says the push for fully autonomous agents "has hit a wall" of unreliability.

I land between the two. Level 3 gives me the most finished work per hour of my attention. Swarmia keeps Level 4 for chores that recur predictably and that nobody is excited to do, such as flaky tests, documentation drift and dependency updates, and that matches where it pays off for me. Level 5 I keep for work where a wrong turn is cheap to throw away.

Level 3 needs a clear ticket and a pipeline that catches mistakes

An autonomous coding agent at Swarmia's Level 3 works unattended only with a clear ticket and a pipeline that catches its mistakes, which is why Swarmia rules that level out for ambiguous work. Swarmia says agents are optimistic. An agent reports the task done when its own reading of the code says so, and only a test it can run proves otherwise.

• A definition of done. If I can't write the acceptance check in two sentences, the task stays in a chat at Level 2, where I can steer.
• Tests the agent can run itself. An agent that can't run the suite checks its work by reading it, and reading is how a broken change passes.
• A machine it can't hurt. The agent works in a fresh sandbox for each task, with the repository cloned into it and no production credentials anywhere on it.
• A place for its questions. An agent that hits a fork in the requirements should stop and ask. That only works when someone sees the question.

I'd spend the most setup time on the last item, because it decides whether the agent saves time or moves the waiting somewhere else.

Running an autonomous coding agent safely on a real repository

An autonomous coding agent on a real repository needs a machine it can't hurt, and I compare the three kinds (containers, virtual machines and remote sandboxes) in sandboxing coding agents.

A thread on r/AI_Agents asks how people run these agents safely on real repositories. My answer starts with a machine I can throw away. The agent can install packages, run the app and break things there, and nothing it does reaches my laptop or production. Approval rules go on the commands that push, delete or spend money, and every read-only command runs without asking. A laptop that sleeps also stops the agent, which is the case for running Claude Code in the cloud.

Running several agents at once brings a checkout problem. Two agents editing the same files at the same time undo each other's work, and I wrote up the ways around it in running multiple Claude Code agents.

Where an autonomous coding agent still waits for a person

An autonomous coding agent still stops for a person at three points: a question the code can't answer, a command that needs approval, and a pull request that needs review. Swarmia warns that autonomous agents can create review burden as easily as they cut coordination overhead.

With one developer running five agents, each stop is a prompt in a terminal that developer already has open. With three developers running five agents each, fifteen agents report to three screens, and each question waits for the developer who started that run. An agent waiting on approval does nothing until that developer looks, and nobody sees how long the agents sit waiting.

I want one queue for the whole team, oldest first, that anyone can answer. A question about the billing service should reach whoever knows billing, no matter who started the run.

How autonomous coding agents run in Aldena

Aldena runs Claude Code or Codex as an agent's runtime inside each conversation's own sandbox, on a sandbox provider the team connects, such as Boat. I built it for teams. A single developer can get far with a local CLI and a container, and I would tell one to start there.

The runtime is per agent. Claude Code runs on each member's own Claude plan, or on the team's Anthropic key for anyone who hasn't signed in. Codex runs on the team's OpenAI key, and ChatGPT plans are not supported yet.

Agents clone the repository into the sandbox, run shell commands, start the app and run its test suite there, and two isolated projects never share a filesystem. The sandbox sleeps 30 minutes after its last command and wakes with the conversation's next turn.

Every tool an agent can call carries an ask, allow or deny policy per project. On ask, the run pauses on the exact call until someone answers allow once, always allow or deny. Asking a person a question is a tool too, and it is the one tool nobody can switch off. Every question and approval goes to the team inbox, grouped by project and oldest first, and any member can answer it.

Code leaves through the Delivery agent, which opens a pull request against the default branch and stops there. No agent merges its own work. An event in GitHub, Bitbucket, Slack, Gmail, Jira, Linear, Notion, Sentry or Vercel can start a run with up to 4,000 characters of the event's text, and agents can set routines for their own recurring work. On Swarmia's scale I'd put that at Level 3, and at Level 4 when an event or a routine starts the run, with a person on every pull request either way.

Choose the autonomy level for each ticket

An autonomous coding agent gets its autonomy level from two questions I ask about each ticket, whether a test can prove it done and whether someone will read the pull request within a day.

Two yeses and the ticket goes to an agent at Level 3. A recurring chore with the same two yeses gets a routine at Level 4. Anything else stays in a chat at Level 2, where I steer it, and the review habits in my AI coding agents guide apply at every level.